// $ANTLR 3.1 ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g 2008-09-04 19:21:34
package com.joa_ebert.as3v.language.as3.antlr;

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import org.antlr.runtime.debug.*;
import java.io.IOException;
public class AS3Parser extends DebugParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "LineTerminator", "WhiteSpace", "MultiLineComment", "SingleLineComment", "Comment", "IdentifierStart", "IdentifierPart", "Identifier", "UnicodeLetter", "UnicodeEscapeSequence", "UnicodeDigit", "UnicodeConnectorPunctuation", "UnicodeCombiningMark", "NullLiteral", "BooleanLiteral", "NumericLiteral", "StringLiteral", "DecimalLiteral", "HexIntegerLiteral", "HexDigit", "DecimalDigit", "ExponentPart", "DoubleStringCharacter", "SingleStringCharacter", "EscapeSequence", "CharacterEscapeSequence", "HexEscapeSequence", "SingleEscapeCharacter", "NonEscapeCharacter", "EscapeCharacter", "'this'", "'super'", "'('", "')'", "'['", "','", "']'", "'{'", "'}'", "':'", "'new'", "'.'", "'::'", "'++'", "'--'", "'delete'", "'void'", "'typeof'", "'as'", "'+'", "'-'", "'~'", "'!'", "'*'", "'/'", "'%'", "'<<'", "'>>'", "'>>>'", "'<'", "'>'", "'<='", "'>='", "'instanceof'", "'is'", "'in'", "'=='", "'!='", "'==='", "'!=='", "'&'", "'^'", "'|'", "'&&'", "'||'", "'?'", "'='", "'*='", "'/='", "'%='", "'+='", "'-='", "'<<='", "'>>='", "'>>>='", "'&='", "'^='", "'|='", "'var'", "'const'", "';'", "'if'", "'else'", "'do'", "'while'", "'for'", "'continue'", "'break'", "'return'", "'with'", "'switch'", "'case'", "'default'", "'throw'", "'try'", "'catch'", "'finally'", "'function'", "'get'", "'set'", "'...'", "'package'", "'import'", "'.*'", "'final'", "'public'", "'internal'", "'class'", "'interface'", "'extends'", "'implements'", "'override'", "'static'", "'use'", "'namespace'", "'include'", "'private'", "'protected'", "'.<'"
    };
    public static final int DecimalDigit=24;
    public static final int EOF=-1;
    public static final int Identifier=11;
    public static final int SingleStringCharacter=27;
    public static final int T__93=93;
    public static final int T__94=94;
    public static final int T__91=91;
    public static final int T__92=92;
    public static final int T__90=90;
    public static final int Comment=8;
    public static final int SingleEscapeCharacter=31;
    public static final int ExponentPart=25;
    public static final int UnicodeLetter=12;
    public static final int WhiteSpace=5;
    public static final int T__99=99;
    public static final int T__98=98;
    public static final int T__97=97;
    public static final int T__96=96;
    public static final int UnicodeCombiningMark=16;
    public static final int T__95=95;
    public static final int UnicodeDigit=14;
    public static final int T__80=80;
    public static final int NumericLiteral=19;
    public static final int T__81=81;
    public static final int T__82=82;
    public static final int T__83=83;
    public static final int IdentifierStart=9;
    public static final int DoubleStringCharacter=26;
    public static final int T__85=85;
    public static final int T__84=84;
    public static final int T__87=87;
    public static final int T__86=86;
    public static final int T__89=89;
    public static final int T__88=88;
    public static final int T__126=126;
    public static final int T__125=125;
    public static final int T__128=128;
    public static final int T__127=127;
    public static final int T__71=71;
    public static final int T__129=129;
    public static final int T__72=72;
    public static final int T__70=70;
    public static final int CharacterEscapeSequence=29;
    public static final int T__76=76;
    public static final int T__75=75;
    public static final int T__130=130;
    public static final int T__74=74;
    public static final int EscapeSequence=28;
    public static final int T__131=131;
    public static final int T__73=73;
    public static final int T__132=132;
    public static final int BooleanLiteral=18;
    public static final int T__79=79;
    public static final int UnicodeConnectorPunctuation=15;
    public static final int T__78=78;
    public static final int T__77=77;
    public static final int T__68=68;
    public static final int T__69=69;
    public static final int T__66=66;
    public static final int NullLiteral=17;
    public static final int T__67=67;
    public static final int T__64=64;
    public static final int T__65=65;
    public static final int T__62=62;
    public static final int HexEscapeSequence=30;
    public static final int T__63=63;
    public static final int SingleLineComment=7;
    public static final int T__118=118;
    public static final int T__119=119;
    public static final int T__116=116;
    public static final int T__117=117;
    public static final int T__114=114;
    public static final int T__115=115;
    public static final int T__124=124;
    public static final int T__123=123;
    public static final int T__122=122;
    public static final int T__121=121;
    public static final int T__120=120;
    public static final int T__61=61;
    public static final int T__60=60;
    public static final int HexDigit=23;
    public static final int T__55=55;
    public static final int T__56=56;
    public static final int T__57=57;
    public static final int T__58=58;
    public static final int T__51=51;
    public static final int T__52=52;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int T__107=107;
    public static final int T__108=108;
    public static final int T__109=109;
    public static final int T__59=59;
    public static final int T__103=103;
    public static final int T__104=104;
    public static final int T__105=105;
    public static final int T__106=106;
    public static final int T__111=111;
    public static final int T__110=110;
    public static final int T__113=113;
    public static final int EscapeCharacter=33;
    public static final int T__112=112;
    public static final int T__50=50;
    public static final int IdentifierPart=10;
    public static final int MultiLineComment=6;
    public static final int T__42=42;
    public static final int T__43=43;
    public static final int T__40=40;
    public static final int T__41=41;
    public static final int T__46=46;
    public static final int T__47=47;
    public static final int T__44=44;
    public static final int T__45=45;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int UnicodeEscapeSequence=13;
    public static final int T__102=102;
    public static final int T__101=101;
    public static final int T__100=100;
    public static final int DecimalLiteral=21;
    public static final int StringLiteral=20;
    public static final int T__34=34;
    public static final int T__35=35;
    public static final int T__36=36;
    public static final int T__37=37;
    public static final int T__38=38;
    public static final int T__39=39;
    public static final int HexIntegerLiteral=22;
    public static final int LineTerminator=4;
    public static final int NonEscapeCharacter=32;

    // delegates
    // delegators

    public static final String[] ruleNames = new String[] {
        "invalidRule", "synpred69_AS3", "synpred118_AS3", "synpred273_AS3", 
        "caseClause", "memberExpressionSuffix", "synpred165_AS3", "synpred296_AS3", 
        "synpred255_AS3", "synpred266_AS3", "propertyNameAndValue", "synpred77_AS3", 
        "forStatement", "synpred351_AS3", "synpred112_AS3", "synpred7_AS3", 
        "synpred135_AS3", "synpred195_AS3", "synpred21_AS3", "callExpressionSuffix", 
        "synpred126_AS3", "variableDeclarationListNoIn", "synpred215_AS3", 
        "synpred75_AS3", "synpred93_AS3", "synpred263_AS3", "synpred220_AS3", 
        "synpred244_AS3", "interfaceImplementations", "synpred41_AS3", "synpred142_AS3", 
        "functionDeclaration", "synpred119_AS3", "synpred124_AS3", "synpred353_AS3", 
        "synpred314_AS3", "expression", "synpred45_AS3", "synpred410_AS3", 
        "synpred22_AS3", "synpred40_AS3", "synpred32_AS3", "synpred76_AS3", 
        "synpred14_AS3", "synpred51_AS3", "synpred238_AS3", "statement", 
        "synpred223_AS3", "synpred356_AS3", "metaDataStatement", "synpred184_AS3", 
        "synpred139_AS3", "throwStatement", "synpred182_AS3", "synpred383_AS3", 
        "synpred367_AS3", "synpred365_AS3", "synpred229_AS3", "synpred349_AS3", 
        "synpred121_AS3", "compilationUnit", "synpred19_AS3", "synpred354_AS3", 
        "synpred240_AS3", "synpred140_AS3", "synpred39_AS3", "ifStatement", 
        "synpred231_AS3", "synpred347_AS3", "synpred56_AS3", "defaultClause", 
        "synpred162_AS3", "synpred258_AS3", "synpred105_AS3", "synpred205_AS3", 
        "synpred176_AS3", "synpred211_AS3", "synpred399_AS3", "synpred79_AS3", 
        "synpred155_AS3", "forInStatement", "packageDeclaration", "bitwiseANDExpressionNoIn", 
        "synpred298_AS3", "synpred327_AS3", "synpred33_AS3", "assignmentExpressionNoIn", 
        "synpred68_AS3", "assignmentOperator", "variableDeclarationNoIn", 
        "synpred73_AS3", "synpred117_AS3", "normalInterfaceDeclaration", 
        "synpred402_AS3", "synpred322_AS3", "synpred432_AS3", "synpred145_AS3", 
        "synpred101_AS3", "synpred15_AS3", "synpred339_AS3", "synpred53_AS3", 
        "doWhileStatement", "synpred429_AS3", "synpred174_AS3", "synpred281_AS3", 
        "synpred279_AS3", "synpred329_AS3", "synpred127_AS3", "synpred156_AS3", 
        "synpred151_AS3", "synpred193_AS3", "synpred393_AS3", "synpred115_AS3", 
        "whileStatement", "synpred64_AS3", "synpred94_AS3", "synpred122_AS3", 
        "synpred363_AS3", "multiplicativeExpression", "formalParameterList", 
        "synpred2_AS3", "synpred306_AS3", "synpred311_AS3", "synpred43_AS3", 
        "synpred172_AS3", "synpred206_AS3", "synpred62_AS3", "synpred422_AS3", 
        "synpred316_AS3", "synpred269_AS3", "synpred319_AS3", "synpred24_AS3", 
        "synpred379_AS3", "synpred283_AS3", "synpred128_AS3", "synpred376_AS3", 
        "synpred423_AS3", "synpred328_AS3", "synpred297_AS3", "caseBlock", 
        "synpred359_AS3", "synpred161_AS3", "callExpression", "synpred150_AS3", 
        "synpred247_AS3", "synpred95_AS3", "synpred167_AS3", "synpred26_AS3", 
        "synpred267_AS3", "synpred70_AS3", "synpred433_AS3", "synpred18_AS3", 
        "synpred408_AS3", "synpred287_AS3", "synpred288_AS3", "synpred280_AS3", 
        "synpred338_AS3", "synpred421_AS3", "synpred425_AS3", "synpred409_AS3", 
        "variableDeclarationList", "synpred350_AS3", "synpred100_AS3", "synpred337_AS3", 
        "synpred98_AS3", "synpred61_AS3", "synpred419_AS3", "synpred213_AS3", 
        "synpred377_AS3", "synpred323_AS3", "synpred170_AS3", "synpred398_AS3", 
        "inheritance", "initialiserNoIn", "synpred166_AS3", "synpred378_AS3", 
        "normalClassDeclaration", "synpred243_AS3", "iterationStatement", 
        "synpred87_AS3", "synpred415_AS3", "synpred133_AS3", "classDeclaration", 
        "synpred284_AS3", "synpred254_AS3", "leftHandSideExpression", "synpred259_AS3", 
        "synpred130_AS3", "synpred214_AS3", "synpred209_AS3", "synpred224_AS3", 
        "synpred343_AS3", "synpred227_AS3", "memberExpression", "synpred4_AS3", 
        "interfaceElement", "variableStatement", "synpred103_AS3", "synpred8_AS3", 
        "synpred330_AS3", "synpred308_AS3", "synpred366_AS3", "breakStatement", 
        "statementList", "interfaceDeclaration", "synpred385_AS3", "synpred12_AS3", 
        "namespace", "bitwiseORExpressionNoIn", "synpred299_AS3", "synpred406_AS3", 
        "synpred91_AS3", "synpred292_AS3", "synpred217_AS3", "synpred384_AS3", 
        "synpred237_AS3", "synpred434_AS3", "synpred372_AS3", "synpred416_AS3", 
        "synpred268_AS3", "indexSuffix", "synpred183_AS3", "synpred212_AS3", 
        "synpred20_AS3", "synpred364_AS3", "synpred191_AS3", "synpred235_AS3", 
        "synpred3_AS3", "synpred391_AS3", "withStatement", "synpred129_AS3", 
        "synpred189_AS3", "returnStatement", "synpred146_AS3", "synpred86_AS3", 
        "synpred304_AS3", "synpred394_AS3", "synpred261_AS3", "synpred348_AS3", 
        "unaryExpression", "synpred90_AS3", "synpred257_AS3", "bitwiseXORExpression", 
        "synpred207_AS3", "synpred208_AS3", "synpred417_AS3", "synpred72_AS3", 
        "synpred424_AS3", "synpred187_AS3", "synpred25_AS3", "synpred49_AS3", 
        "synpred282_AS3", "assignmentExpression", "synpred109_AS3", "synpred242_AS3", 
        "synpred181_AS3", "synpred197_AS3", "synpred190_AS3", "synpred216_AS3", 
        "bitwiseORExpression", "synpred163_AS3", "synpred78_AS3", "synpred320_AS3", 
        "synpred404_AS3", "synpred375_AS3", "synpred55_AS3", "synpred250_AS3", 
        "synpred116_AS3", "synpred106_AS3", "synpred236_AS3", "synpred403_AS3", 
        "synpred46_AS3", "synpred336_AS3", "synpred430_AS3", "synpred380_AS3", 
        "synpred371_AS3", "synpred16_AS3", "synpred202_AS3", "synpred260_AS3", 
        "synpred290_AS3", "synpred294_AS3", "classElements", "synpred5_AS3", 
        "forInStatementInitialiserPart", "synpred369_AS3", "synpred291_AS3", 
        "synpred270_AS3", "synpred293_AS3", "synpred111_AS3", "synpred114_AS3", 
        "synpred418_AS3", "synpred27_AS3", "synpred325_AS3", "synpred92_AS3", 
        "expressionStatement", "synpred192_AS3", "synpred60_AS3", "synpred96_AS3", 
        "labelledStatement", "synpred173_AS3", "argumentList", "synpred332_AS3", 
        "primaryExpression", "synpred342_AS3", "synpred246_AS3", "synpred120_AS3", 
        "synpred390_AS3", "synpred66_AS3", "synpred89_AS3", "synpred253_AS3", 
        "synpred318_AS3", "synpred300_AS3", "synpred388_AS3", "synpred85_AS3", 
        "synpred295_AS3", "defaultArgumentValue", "bitwiseXORExpressionNoIn", 
        "synpred386_AS3", "synpred313_AS3", "synpred276_AS3", "typeInformation", 
        "formalParameter", "synpred309_AS3", "synpred84_AS3", "synpred272_AS3", 
        "synpred175_AS3", "synpred335_AS3", "synpred179_AS3", "synpred248_AS3", 
        "synpred113_AS3", "newExpression", "synpred152_AS3", "synpred134_AS3", 
        "synpred125_AS3", "synpred286_AS3", "synpred71_AS3", "synpred123_AS3", 
        "synpred221_AS3", "continueStatement", "synpred110_AS3", "sourceElements", 
        "logicalANDExpression", "synpred362_AS3", "synpred38_AS3", "synpred42_AS3", 
        "synpred149_AS3", "synpred302_AS3", "synpred382_AS3", "arrayLiteral", 
        "synpred222_AS3", "shiftExpression", "synpred374_AS3", "synpred357_AS3", 
        "synpred37_AS3", "synpred198_AS3", "synpred427_AS3", "synpred58_AS3", 
        "synpred334_AS3", "type", "synpred196_AS3", "synpred310_AS3", "synpred301_AS3", 
        "synpred177_AS3", "synpred67_AS3", "synpred341_AS3", "synpred262_AS3", 
        "synpred180_AS3", "synpred395_AS3", "synpred169_AS3", "synpred199_AS3", 
        "synpred59_AS3", "synpred154_AS3", "synpred435_AS3", "synpred414_AS3", 
        "synpred188_AS3", "finallyClause", "synpred249_AS3", "synpred397_AS3", 
        "synpred185_AS3", "synpred360_AS3", "synpred141_AS3", "synpred148_AS3", 
        "synpred17_AS3", "synpred131_AS3", "synpred368_AS3", "synpred355_AS3", 
        "synpred1_AS3", "synpred107_AS3", "propertyReferenceSuffix", "synpred143_AS3", 
        "forStatementInitialiserPart", "synpred200_AS3", "synpred426_AS3", 
        "packageElements", "synpred400_AS3", "synpred82_AS3", "synpred210_AS3", 
        "synpred80_AS3", "synpred326_AS3", "synpred411_AS3", "synpred305_AS3", 
        "typeModifier", "variableDeclaration", "synpred164_AS3", "propertyName", 
        "tryStatement", "synpred63_AS3", "synpred387_AS3", "synpred137_AS3", 
        "synpred138_AS3", "logicalORExpressionNoIn", "postfixExpression", 
        "synpred153_AS3", "synpred36_AS3", "synpred203_AS3", "additiveExpression", 
        "synpred370_AS3", "bitwiseANDExpression", "interfaceElements", "synpred83_AS3", 
        "includeStatement", "logicalANDExpressionNoIn", "emptyStatement", 
        "synpred381_AS3", "synpred81_AS3", "synpred428_AS3", "synpred54_AS3", 
        "synpred265_AS3", "literal", "synpred274_AS3", "synpred405_AS3", 
        "synpred52_AS3", "synpred346_AS3", "conditionalExpression", "initialiser", 
        "synpred74_AS3", "synpred35_AS3", "packageElement", "relationalExpressionNoIn", 
        "useNamespaceStatement", "synpred241_AS3", "synpred431_AS3", "sourceElement", 
        "synpred275_AS3", "synpred289_AS3", "synpred344_AS3", "synpred324_AS3", 
        "synpred48_AS3", "blockStatement", "synpred345_AS3", "synpred245_AS3", 
        "synpred178_AS3", "synpred412_AS3", "synpred99_AS3", "synpred147_AS3", 
        "synpred401_AS3", "synpred407_AS3", "synpred420_AS3", "synpred285_AS3", 
        "synpred239_AS3", "synpred88_AS3", "synpred29_AS3", "synpred6_AS3", 
        "synpred30_AS3", "conditionalExpressionNoIn", "synpred392_AS3", 
        "synpred97_AS3", "synpred252_AS3", "synpred34_AS3", "synpred201_AS3", 
        "synpred321_AS3", "logicalORExpression", "synpred194_AS3", "relationalExpression", 
        "synpred44_AS3", "synpred23_AS3", "synpred11_AS3", "synpred264_AS3", 
        "synpred361_AS3", "equalityExpression", "synpred232_AS3", "synpred358_AS3", 
        "classElement", "synpred225_AS3", "synpred233_AS3", "synpred226_AS3", 
        "synpred160_AS3", "synpred333_AS3", "switchStatement", "synpred65_AS3", 
        "synpred312_AS3", "importStatement", "synpred108_AS3", "synpred9_AS3", 
        "synpred340_AS3", "classMember", "synpred307_AS3", "functionExpression", 
        "synpred31_AS3", "expressionNoIn", "synpred228_AS3", "synpred389_AS3", 
        "catchClause", "synpred28_AS3", "synpred102_AS3", "synpred171_AS3", 
        "synpred13_AS3", "synpred47_AS3", "synpred10_AS3", "synpred159_AS3", 
        "synpred136_AS3", "synpred271_AS3", "synpred315_AS3", "synpred158_AS3", 
        "synpred396_AS3", "synpred219_AS3", "synpred303_AS3", "synpred104_AS3", 
        "synpred317_AS3", "synpred277_AS3", "synpred204_AS3", "synpred57_AS3", 
        "synpred256_AS3", "qualifiedName", "equalityExpressionNoIn", "synpred144_AS3", 
        "synpred132_AS3", "synpred352_AS3", "synpred413_AS3", "synpred50_AS3", 
        "synpred278_AS3", "synpred218_AS3", "synpred331_AS3", "synpred230_AS3", 
        "synpred251_AS3", "objectLiteral", "synpred168_AS3", "synpred234_AS3", 
        "synpred186_AS3", "synpred373_AS3", "synpred157_AS3"
    };
     
        public int ruleLevel = 0;
        public int getRuleLevel() { return ruleLevel; }
        public void incRuleLevel() { ruleLevel++; }
        public void decRuleLevel() { ruleLevel--; }
        public AS3Parser(TokenStream input) {
            this(input, DebugEventSocketProxy.DEFAULT_DEBUGGER_PORT, new RecognizerSharedState());
        }
        public AS3Parser(TokenStream input, int port, RecognizerSharedState state) {
            super(input, state);
            this.state.ruleMemo = new HashMap[540+1];
             
            DebugEventSocketProxy proxy =
                new DebugEventSocketProxy(this, port, null);
            setDebugListener(proxy);
            try {
                proxy.handshake();
            }
            catch (IOException ioe) {
                reportError(ioe);
            }
        }
    public AS3Parser(TokenStream input, DebugEventListener dbg) {
        super(input, dbg, new RecognizerSharedState());
        this.state.ruleMemo = new HashMap[540+1];
         
    }
    protected boolean evalPredicate(boolean result, String predicate) {
        dbg.semanticPredicate(result, predicate);
        return result;
    }


    public String[] getTokenNames() { return AS3Parser.tokenNames; }
    public String getGrammarFileName() { return "./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g"; }



    // $ANTLR start "compilationUnit"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:35:1: compilationUnit : ( LineTerminator )* packageDeclaration ( LineTerminator )* ( normalClassDeclaration | normalInterfaceDeclaration )* ( LineTerminator )* EOF ;
    public final void compilationUnit() throws RecognitionException {
        int compilationUnit_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "compilationUnit");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(35, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 1) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:2: ( ( LineTerminator )* packageDeclaration ( LineTerminator )* ( normalClassDeclaration | normalInterfaceDeclaration )* ( LineTerminator )* EOF )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:4: ( LineTerminator )* packageDeclaration ( LineTerminator )* ( normalClassDeclaration | normalInterfaceDeclaration )* ( LineTerminator )* EOF
            {
            dbg.location(36,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:4: ( LineTerminator )*
            try { dbg.enterSubRule(1);

            loop1:
            do {
                int alt1=2;
                try { dbg.enterDecision(1);

                int LA1_0 = input.LA(1);

                if ( (LA1_0==LineTerminator) ) {
                    alt1=1;
                }


                } finally {dbg.exitDecision(1);}

                switch (alt1) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(36,4);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_compilationUnit45); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);
            } finally {dbg.exitSubRule(1);}

            dbg.location(36,20);
            pushFollow(FOLLOW_packageDeclaration_in_compilationUnit48);
            packageDeclaration();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(36,39);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:39: ( LineTerminator )*
            try { dbg.enterSubRule(2);

            loop2:
            do {
                int alt2=2;
                try { dbg.enterDecision(2);

                int LA2_0 = input.LA(1);

                if ( (LA2_0==LineTerminator) ) {
                    int LA2_2 = input.LA(2);

                    if ( (synpred2_AS3()) ) {
                        alt2=1;
                    }


                }


                } finally {dbg.exitDecision(2);}

                switch (alt2) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(36,39);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_compilationUnit50); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);
            } finally {dbg.exitSubRule(2);}

            dbg.location(36,55);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:55: ( normalClassDeclaration | normalInterfaceDeclaration )*
            try { dbg.enterSubRule(3);

            loop3:
            do {
                int alt3=3;
                try { dbg.enterDecision(3);

                try {
                    isCyclicDecision = true;
                    alt3 = dfa3.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(3);}

                switch (alt3) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:56: normalClassDeclaration
            	    {
            	    dbg.location(36,56);
            	    pushFollow(FOLLOW_normalClassDeclaration_in_compilationUnit54);
            	    normalClassDeclaration();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;
            	case 2 :
            	    dbg.enterAlt(2);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:79: normalInterfaceDeclaration
            	    {
            	    dbg.location(36,79);
            	    pushFollow(FOLLOW_normalInterfaceDeclaration_in_compilationUnit56);
            	    normalInterfaceDeclaration();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop3;
                }
            } while (true);
            } finally {dbg.exitSubRule(3);}

            dbg.location(36,108);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:108: ( LineTerminator )*
            try { dbg.enterSubRule(4);

            loop4:
            do {
                int alt4=2;
                try { dbg.enterDecision(4);

                int LA4_0 = input.LA(1);

                if ( (LA4_0==LineTerminator) ) {
                    alt4=1;
                }


                } finally {dbg.exitDecision(4);}

                switch (alt4) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(36,108);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_compilationUnit60); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);
            } finally {dbg.exitSubRule(4);}

            dbg.location(36,124);
            match(input,EOF,FOLLOW_EOF_in_compilationUnit63); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 1, compilationUnit_StartIndex); }
        }
        dbg.location(37, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "compilationUnit");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "compilationUnit"


    // $ANTLR start "literal"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:590:1: literal : ( NullLiteral | BooleanLiteral | NumericLiteral | StringLiteral );
    public final void literal() throws RecognitionException {
        int literal_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "literal");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(590, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 2) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:591:2: ( NullLiteral | BooleanLiteral | NumericLiteral | StringLiteral )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:
            {
            dbg.location(591,2);
            if ( (input.LA(1)>=NullLiteral && input.LA(1)<=StringLiteral) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 2, literal_StartIndex); }
        }
        dbg.location(595, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "literal");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "literal"


    // $ANTLR start "primaryExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:690:1: primaryExpression : ( 'this' | 'super' | Identifier | qualifiedName | literal | arrayLiteral | objectLiteral | '(' ( LineTerminator )* expression ( LineTerminator )* ')' );
    public final void primaryExpression() throws RecognitionException {
        int primaryExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "primaryExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(690, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 3) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:691:2: ( 'this' | 'super' | Identifier | qualifiedName | literal | arrayLiteral | objectLiteral | '(' ( LineTerminator )* expression ( LineTerminator )* ')' )
            int alt7=8;
            try { dbg.enterDecision(7);

            try {
                isCyclicDecision = true;
                alt7 = dfa7.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(7);}

            switch (alt7) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:691:4: 'this'
                    {
                    dbg.location(691,4);
                    match(input,34,FOLLOW_34_in_primaryExpression3521); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:692:4: 'super'
                    {
                    dbg.location(692,4);
                    match(input,35,FOLLOW_35_in_primaryExpression3526); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:693:4: Identifier
                    {
                    dbg.location(693,4);
                    match(input,Identifier,FOLLOW_Identifier_in_primaryExpression3531); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:694:4: qualifiedName
                    {
                    dbg.location(694,4);
                    pushFollow(FOLLOW_qualifiedName_in_primaryExpression3536);
                    qualifiedName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:695:4: literal
                    {
                    dbg.location(695,4);
                    pushFollow(FOLLOW_literal_in_primaryExpression3541);
                    literal();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:696:4: arrayLiteral
                    {
                    dbg.location(696,4);
                    pushFollow(FOLLOW_arrayLiteral_in_primaryExpression3546);
                    arrayLiteral();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    dbg.enterAlt(7);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:697:4: objectLiteral
                    {
                    dbg.location(697,4);
                    pushFollow(FOLLOW_objectLiteral_in_primaryExpression3551);
                    objectLiteral();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 8 :
                    dbg.enterAlt(8);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:698:4: '(' ( LineTerminator )* expression ( LineTerminator )* ')'
                    {
                    dbg.location(698,4);
                    match(input,36,FOLLOW_36_in_primaryExpression3556); if (state.failed) return ;
                    dbg.location(698,9);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:698:9: ( LineTerminator )*
                    try { dbg.enterSubRule(5);

                    loop5:
                    do {
                        int alt5=2;
                        try { dbg.enterDecision(5);

                        int LA5_0 = input.LA(1);

                        if ( (LA5_0==LineTerminator) ) {
                            alt5=1;
                        }


                        } finally {dbg.exitDecision(5);}

                        switch (alt5) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(698,9);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_primaryExpression3559); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop5;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(5);}

                    dbg.location(698,25);
                    pushFollow(FOLLOW_expression_in_primaryExpression3562);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(698,36);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:698:36: ( LineTerminator )*
                    try { dbg.enterSubRule(6);

                    loop6:
                    do {
                        int alt6=2;
                        try { dbg.enterDecision(6);

                        int LA6_0 = input.LA(1);

                        if ( (LA6_0==LineTerminator) ) {
                            alt6=1;
                        }


                        } finally {dbg.exitDecision(6);}

                        switch (alt6) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(698,36);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_primaryExpression3564); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop6;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(6);}

                    dbg.location(698,52);
                    match(input,37,FOLLOW_37_in_primaryExpression3567); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 3, primaryExpression_StartIndex); }
        }
        dbg.location(699, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "primaryExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "primaryExpression"


    // $ANTLR start "arrayLiteral"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:701:1: arrayLiteral : '[' ( LineTerminator )* ( assignmentExpression )? ( ( LineTerminator )* ',' ( ( LineTerminator )* assignmentExpression )? )* ( LineTerminator )* ']' ;
    public final void arrayLiteral() throws RecognitionException {
        int arrayLiteral_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "arrayLiteral");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(701, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 4) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:2: ( '[' ( LineTerminator )* ( assignmentExpression )? ( ( LineTerminator )* ',' ( ( LineTerminator )* assignmentExpression )? )* ( LineTerminator )* ']' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:4: '[' ( LineTerminator )* ( assignmentExpression )? ( ( LineTerminator )* ',' ( ( LineTerminator )* assignmentExpression )? )* ( LineTerminator )* ']'
            {
            dbg.location(702,4);
            match(input,38,FOLLOW_38_in_arrayLiteral3579); if (state.failed) return ;
            dbg.location(702,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:8: ( LineTerminator )*
            try { dbg.enterSubRule(8);

            loop8:
            do {
                int alt8=2;
                try { dbg.enterDecision(8);

                int LA8_0 = input.LA(1);

                if ( (LA8_0==LineTerminator) ) {
                    int LA8_2 = input.LA(2);

                    if ( (synpred18_AS3()) ) {
                        alt8=1;
                    }


                }


                } finally {dbg.exitDecision(8);}

                switch (alt8) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(702,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_arrayLiteral3581); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop8;
                }
            } while (true);
            } finally {dbg.exitSubRule(8);}

            dbg.location(702,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:24: ( assignmentExpression )?
            int alt9=2;
            try { dbg.enterSubRule(9);
            try { dbg.enterDecision(9);

            int LA9_0 = input.LA(1);

            if ( (LA9_0==Identifier||(LA9_0>=NullLiteral && LA9_0<=StringLiteral)||(LA9_0>=34 && LA9_0<=36)||LA9_0==38||LA9_0==41||LA9_0==44||(LA9_0>=47 && LA9_0<=56)||LA9_0==111) ) {
                alt9=1;
            }
            } finally {dbg.exitDecision(9);}

            switch (alt9) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: assignmentExpression
                    {
                    dbg.location(702,24);
                    pushFollow(FOLLOW_assignmentExpression_in_arrayLiteral3584);
                    assignmentExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(9);}

            dbg.location(702,46);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:46: ( ( LineTerminator )* ',' ( ( LineTerminator )* assignmentExpression )? )*
            try { dbg.enterSubRule(13);

            loop13:
            do {
                int alt13=2;
                try { dbg.enterDecision(13);

                try {
                    isCyclicDecision = true;
                    alt13 = dfa13.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(13);}

                switch (alt13) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:47: ( LineTerminator )* ',' ( ( LineTerminator )* assignmentExpression )?
            	    {
            	    dbg.location(702,47);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:47: ( LineTerminator )*
            	    try { dbg.enterSubRule(10);

            	    loop10:
            	    do {
            	        int alt10=2;
            	        try { dbg.enterDecision(10);

            	        int LA10_0 = input.LA(1);

            	        if ( (LA10_0==LineTerminator) ) {
            	            alt10=1;
            	        }


            	        } finally {dbg.exitDecision(10);}

            	        switch (alt10) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(702,47);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_arrayLiteral3588); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop10;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(10);}

            	    dbg.location(702,63);
            	    match(input,39,FOLLOW_39_in_arrayLiteral3591); if (state.failed) return ;
            	    dbg.location(702,67);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:67: ( ( LineTerminator )* assignmentExpression )?
            	    int alt12=2;
            	    try { dbg.enterSubRule(12);
            	    try { dbg.enterDecision(12);

            	    try {
            	        isCyclicDecision = true;
            	        alt12 = dfa12.predict(input);
            	    }
            	    catch (NoViableAltException nvae) {
            	        dbg.recognitionException(nvae);
            	        throw nvae;
            	    }
            	    } finally {dbg.exitDecision(12);}

            	    switch (alt12) {
            	        case 1 :
            	            dbg.enterAlt(1);

            	            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:68: ( LineTerminator )* assignmentExpression
            	            {
            	            dbg.location(702,68);
            	            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:68: ( LineTerminator )*
            	            try { dbg.enterSubRule(11);

            	            loop11:
            	            do {
            	                int alt11=2;
            	                try { dbg.enterDecision(11);

            	                int LA11_0 = input.LA(1);

            	                if ( (LA11_0==LineTerminator) ) {
            	                    alt11=1;
            	                }


            	                } finally {dbg.exitDecision(11);}

            	                switch (alt11) {
            	            	case 1 :
            	            	    dbg.enterAlt(1);

            	            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	            	    {
            	            	    dbg.location(702,68);
            	            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_arrayLiteral3594); if (state.failed) return ;

            	            	    }
            	            	    break;

            	            	default :
            	            	    break loop11;
            	                }
            	            } while (true);
            	            } finally {dbg.exitSubRule(11);}

            	            dbg.location(702,84);
            	            pushFollow(FOLLOW_assignmentExpression_in_arrayLiteral3597);
            	            assignmentExpression();

            	            state._fsp--;
            	            if (state.failed) return ;

            	            }
            	            break;

            	    }
            	    } finally {dbg.exitSubRule(12);}


            	    }
            	    break;

            	default :
            	    break loop13;
                }
            } while (true);
            } finally {dbg.exitSubRule(13);}

            dbg.location(702,109);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:109: ( LineTerminator )*
            try { dbg.enterSubRule(14);

            loop14:
            do {
                int alt14=2;
                try { dbg.enterDecision(14);

                int LA14_0 = input.LA(1);

                if ( (LA14_0==LineTerminator) ) {
                    alt14=1;
                }


                } finally {dbg.exitDecision(14);}

                switch (alt14) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(702,109);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_arrayLiteral3603); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop14;
                }
            } while (true);
            } finally {dbg.exitSubRule(14);}

            dbg.location(702,125);
            match(input,40,FOLLOW_40_in_arrayLiteral3606); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 4, arrayLiteral_StartIndex); }
        }
        dbg.location(703, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "arrayLiteral");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "arrayLiteral"


    // $ANTLR start "objectLiteral"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:705:1: objectLiteral : '{' ( LineTerminator )* ( propertyNameAndValue ( ( LineTerminator )* ',' ( LineTerminator )* propertyNameAndValue )* ( LineTerminator )* )? '}' ;
    public final void objectLiteral() throws RecognitionException {
        int objectLiteral_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "objectLiteral");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(705, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 5) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:2: ( '{' ( LineTerminator )* ( propertyNameAndValue ( ( LineTerminator )* ',' ( LineTerminator )* propertyNameAndValue )* ( LineTerminator )* )? '}' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:4: '{' ( LineTerminator )* ( propertyNameAndValue ( ( LineTerminator )* ',' ( LineTerminator )* propertyNameAndValue )* ( LineTerminator )* )? '}'
            {
            dbg.location(706,4);
            match(input,41,FOLLOW_41_in_objectLiteral3618); if (state.failed) return ;
            dbg.location(706,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:8: ( LineTerminator )*
            try { dbg.enterSubRule(15);

            loop15:
            do {
                int alt15=2;
                try { dbg.enterDecision(15);

                int LA15_0 = input.LA(1);

                if ( (LA15_0==LineTerminator) ) {
                    alt15=1;
                }


                } finally {dbg.exitDecision(15);}

                switch (alt15) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(706,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_objectLiteral3620); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop15;
                }
            } while (true);
            } finally {dbg.exitSubRule(15);}

            dbg.location(706,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:24: ( propertyNameAndValue ( ( LineTerminator )* ',' ( LineTerminator )* propertyNameAndValue )* ( LineTerminator )* )?
            int alt20=2;
            try { dbg.enterSubRule(20);
            try { dbg.enterDecision(20);

            int LA20_0 = input.LA(1);

            if ( (LA20_0==Identifier||(LA20_0>=NumericLiteral && LA20_0<=StringLiteral)) ) {
                alt20=1;
            }
            } finally {dbg.exitDecision(20);}

            switch (alt20) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:25: propertyNameAndValue ( ( LineTerminator )* ',' ( LineTerminator )* propertyNameAndValue )* ( LineTerminator )*
                    {
                    dbg.location(706,25);
                    pushFollow(FOLLOW_propertyNameAndValue_in_objectLiteral3624);
                    propertyNameAndValue();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(706,46);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:46: ( ( LineTerminator )* ',' ( LineTerminator )* propertyNameAndValue )*
                    try { dbg.enterSubRule(18);

                    loop18:
                    do {
                        int alt18=2;
                        try { dbg.enterDecision(18);

                        try {
                            isCyclicDecision = true;
                            alt18 = dfa18.predict(input);
                        }
                        catch (NoViableAltException nvae) {
                            dbg.recognitionException(nvae);
                            throw nvae;
                        }
                        } finally {dbg.exitDecision(18);}

                        switch (alt18) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:47: ( LineTerminator )* ',' ( LineTerminator )* propertyNameAndValue
                    	    {
                    	    dbg.location(706,47);
                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:47: ( LineTerminator )*
                    	    try { dbg.enterSubRule(16);

                    	    loop16:
                    	    do {
                    	        int alt16=2;
                    	        try { dbg.enterDecision(16);

                    	        int LA16_0 = input.LA(1);

                    	        if ( (LA16_0==LineTerminator) ) {
                    	            alt16=1;
                    	        }


                    	        } finally {dbg.exitDecision(16);}

                    	        switch (alt16) {
                    	    	case 1 :
                    	    	    dbg.enterAlt(1);

                    	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    	    {
                    	    	    dbg.location(706,47);
                    	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_objectLiteral3627); if (state.failed) return ;

                    	    	    }
                    	    	    break;

                    	    	default :
                    	    	    break loop16;
                    	        }
                    	    } while (true);
                    	    } finally {dbg.exitSubRule(16);}

                    	    dbg.location(706,63);
                    	    match(input,39,FOLLOW_39_in_objectLiteral3630); if (state.failed) return ;
                    	    dbg.location(706,67);
                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:67: ( LineTerminator )*
                    	    try { dbg.enterSubRule(17);

                    	    loop17:
                    	    do {
                    	        int alt17=2;
                    	        try { dbg.enterDecision(17);

                    	        int LA17_0 = input.LA(1);

                    	        if ( (LA17_0==LineTerminator) ) {
                    	            alt17=1;
                    	        }


                    	        } finally {dbg.exitDecision(17);}

                    	        switch (alt17) {
                    	    	case 1 :
                    	    	    dbg.enterAlt(1);

                    	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    	    {
                    	    	    dbg.location(706,67);
                    	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_objectLiteral3632); if (state.failed) return ;

                    	    	    }
                    	    	    break;

                    	    	default :
                    	    	    break loop17;
                    	        }
                    	    } while (true);
                    	    } finally {dbg.exitSubRule(17);}

                    	    dbg.location(706,83);
                    	    pushFollow(FOLLOW_propertyNameAndValue_in_objectLiteral3635);
                    	    propertyNameAndValue();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop18;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(18);}

                    dbg.location(706,106);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:706:106: ( LineTerminator )*
                    try { dbg.enterSubRule(19);

                    loop19:
                    do {
                        int alt19=2;
                        try { dbg.enterDecision(19);

                        int LA19_0 = input.LA(1);

                        if ( (LA19_0==LineTerminator) ) {
                            alt19=1;
                        }


                        } finally {dbg.exitDecision(19);}

                        switch (alt19) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(706,106);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_objectLiteral3639); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop19;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(19);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(20);}

            dbg.location(706,124);
            match(input,42,FOLLOW_42_in_objectLiteral3644); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 5, objectLiteral_StartIndex); }
        }
        dbg.location(707, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "objectLiteral");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "objectLiteral"


    // $ANTLR start "propertyNameAndValue"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:709:1: propertyNameAndValue : propertyName ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression ;
    public final void propertyNameAndValue() throws RecognitionException {
        int propertyNameAndValue_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "propertyNameAndValue");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(709, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 6) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:710:2: ( propertyName ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:710:4: propertyName ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression
            {
            dbg.location(710,4);
            pushFollow(FOLLOW_propertyName_in_propertyNameAndValue3655);
            propertyName();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(710,17);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:710:17: ( LineTerminator )*
            try { dbg.enterSubRule(21);

            loop21:
            do {
                int alt21=2;
                try { dbg.enterDecision(21);

                int LA21_0 = input.LA(1);

                if ( (LA21_0==LineTerminator) ) {
                    alt21=1;
                }


                } finally {dbg.exitDecision(21);}

                switch (alt21) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(710,17);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_propertyNameAndValue3657); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop21;
                }
            } while (true);
            } finally {dbg.exitSubRule(21);}

            dbg.location(710,33);
            match(input,43,FOLLOW_43_in_propertyNameAndValue3660); if (state.failed) return ;
            dbg.location(710,37);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:710:37: ( LineTerminator )*
            try { dbg.enterSubRule(22);

            loop22:
            do {
                int alt22=2;
                try { dbg.enterDecision(22);

                int LA22_0 = input.LA(1);

                if ( (LA22_0==LineTerminator) ) {
                    alt22=1;
                }


                } finally {dbg.exitDecision(22);}

                switch (alt22) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(710,37);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_propertyNameAndValue3662); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop22;
                }
            } while (true);
            } finally {dbg.exitSubRule(22);}

            dbg.location(710,53);
            pushFollow(FOLLOW_assignmentExpression_in_propertyNameAndValue3665);
            assignmentExpression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 6, propertyNameAndValue_StartIndex); }
        }
        dbg.location(711, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "propertyNameAndValue");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "propertyNameAndValue"


    // $ANTLR start "propertyName"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:713:1: propertyName : ( Identifier | StringLiteral | NumericLiteral );
    public final void propertyName() throws RecognitionException {
        int propertyName_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "propertyName");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(713, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 7) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:714:2: ( Identifier | StringLiteral | NumericLiteral )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:
            {
            dbg.location(714,2);
            if ( input.LA(1)==Identifier||(input.LA(1)>=NumericLiteral && input.LA(1)<=StringLiteral) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 7, propertyName_StartIndex); }
        }
        dbg.location(717, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "propertyName");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "propertyName"


    // $ANTLR start "memberExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:719:1: memberExpression : ( primaryExpression | functionExpression | 'new' ( LineTerminator )* memberExpression ( LineTerminator )* argumentList ) ( ( LineTerminator )* memberExpressionSuffix )* ;
    public final void memberExpression() throws RecognitionException {
        int memberExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "memberExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(719, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 8) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:2: ( ( primaryExpression | functionExpression | 'new' ( LineTerminator )* memberExpression ( LineTerminator )* argumentList ) ( ( LineTerminator )* memberExpressionSuffix )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:4: ( primaryExpression | functionExpression | 'new' ( LineTerminator )* memberExpression ( LineTerminator )* argumentList ) ( ( LineTerminator )* memberExpressionSuffix )*
            {
            dbg.location(720,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:4: ( primaryExpression | functionExpression | 'new' ( LineTerminator )* memberExpression ( LineTerminator )* argumentList )
            int alt25=3;
            try { dbg.enterSubRule(25);
            try { dbg.enterDecision(25);

            switch ( input.LA(1) ) {
            case Identifier:
            case NullLiteral:
            case BooleanLiteral:
            case NumericLiteral:
            case StringLiteral:
            case 34:
            case 35:
            case 36:
            case 38:
            case 41:
                {
                alt25=1;
                }
                break;
            case 111:
                {
                alt25=2;
                }
                break;
            case 44:
                {
                alt25=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(25);}

            switch (alt25) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:5: primaryExpression
                    {
                    dbg.location(720,5);
                    pushFollow(FOLLOW_primaryExpression_in_memberExpression3699);
                    primaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:25: functionExpression
                    {
                    dbg.location(720,25);
                    pushFollow(FOLLOW_functionExpression_in_memberExpression3703);
                    functionExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:46: 'new' ( LineTerminator )* memberExpression ( LineTerminator )* argumentList
                    {
                    dbg.location(720,46);
                    match(input,44,FOLLOW_44_in_memberExpression3707); if (state.failed) return ;
                    dbg.location(720,52);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:52: ( LineTerminator )*
                    try { dbg.enterSubRule(23);

                    loop23:
                    do {
                        int alt23=2;
                        try { dbg.enterDecision(23);

                        int LA23_0 = input.LA(1);

                        if ( (LA23_0==LineTerminator) ) {
                            alt23=1;
                        }


                        } finally {dbg.exitDecision(23);}

                        switch (alt23) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(720,52);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_memberExpression3709); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop23;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(23);}

                    dbg.location(720,68);
                    pushFollow(FOLLOW_memberExpression_in_memberExpression3712);
                    memberExpression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(720,85);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:85: ( LineTerminator )*
                    try { dbg.enterSubRule(24);

                    loop24:
                    do {
                        int alt24=2;
                        try { dbg.enterDecision(24);

                        int LA24_0 = input.LA(1);

                        if ( (LA24_0==LineTerminator) ) {
                            alt24=1;
                        }


                        } finally {dbg.exitDecision(24);}

                        switch (alt24) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(720,85);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_memberExpression3714); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop24;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(24);}

                    dbg.location(720,101);
                    pushFollow(FOLLOW_argumentList_in_memberExpression3717);
                    argumentList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(25);}

            dbg.location(720,115);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:115: ( ( LineTerminator )* memberExpressionSuffix )*
            try { dbg.enterSubRule(27);

            loop27:
            do {
                int alt27=2;
                try { dbg.enterDecision(27);

                try {
                    isCyclicDecision = true;
                    alt27 = dfa27.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(27);}

                switch (alt27) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:116: ( LineTerminator )* memberExpressionSuffix
            	    {
            	    dbg.location(720,116);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:116: ( LineTerminator )*
            	    try { dbg.enterSubRule(26);

            	    loop26:
            	    do {
            	        int alt26=2;
            	        try { dbg.enterDecision(26);

            	        int LA26_0 = input.LA(1);

            	        if ( (LA26_0==LineTerminator) ) {
            	            alt26=1;
            	        }


            	        } finally {dbg.exitDecision(26);}

            	        switch (alt26) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(720,116);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_memberExpression3721); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop26;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(26);}

            	    dbg.location(720,132);
            	    pushFollow(FOLLOW_memberExpressionSuffix_in_memberExpression3724);
            	    memberExpressionSuffix();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop27;
                }
            } while (true);
            } finally {dbg.exitSubRule(27);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 8, memberExpression_StartIndex); }
        }
        dbg.location(721, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "memberExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "memberExpression"


    // $ANTLR start "memberExpressionSuffix"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:723:1: memberExpressionSuffix : ( indexSuffix | propertyReferenceSuffix );
    public final void memberExpressionSuffix() throws RecognitionException {
        int memberExpressionSuffix_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "memberExpressionSuffix");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(723, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 9) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:724:2: ( indexSuffix | propertyReferenceSuffix )
            int alt28=2;
            try { dbg.enterDecision(28);

            int LA28_0 = input.LA(1);

            if ( (LA28_0==38) ) {
                alt28=1;
            }
            else if ( (LA28_0==45) ) {
                alt28=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 28, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(28);}

            switch (alt28) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:724:4: indexSuffix
                    {
                    dbg.location(724,4);
                    pushFollow(FOLLOW_indexSuffix_in_memberExpressionSuffix3738);
                    indexSuffix();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:725:4: propertyReferenceSuffix
                    {
                    dbg.location(725,4);
                    pushFollow(FOLLOW_propertyReferenceSuffix_in_memberExpressionSuffix3743);
                    propertyReferenceSuffix();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 9, memberExpressionSuffix_StartIndex); }
        }
        dbg.location(726, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "memberExpressionSuffix");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "memberExpressionSuffix"


    // $ANTLR start "newExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:728:1: newExpression : ( memberExpression | 'new' ( LineTerminator )* newExpression );
    public final void newExpression() throws RecognitionException {
        int newExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "newExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(728, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 10) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:729:2: ( memberExpression | 'new' ( LineTerminator )* newExpression )
            int alt30=2;
            try { dbg.enterDecision(30);

            try {
                isCyclicDecision = true;
                alt30 = dfa30.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(30);}

            switch (alt30) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:729:4: memberExpression
                    {
                    dbg.location(729,4);
                    pushFollow(FOLLOW_memberExpression_in_newExpression3755);
                    memberExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:730:4: 'new' ( LineTerminator )* newExpression
                    {
                    dbg.location(730,4);
                    match(input,44,FOLLOW_44_in_newExpression3760); if (state.failed) return ;
                    dbg.location(730,10);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:730:10: ( LineTerminator )*
                    try { dbg.enterSubRule(29);

                    loop29:
                    do {
                        int alt29=2;
                        try { dbg.enterDecision(29);

                        int LA29_0 = input.LA(1);

                        if ( (LA29_0==LineTerminator) ) {
                            alt29=1;
                        }


                        } finally {dbg.exitDecision(29);}

                        switch (alt29) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(730,10);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_newExpression3762); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop29;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(29);}

                    dbg.location(730,26);
                    pushFollow(FOLLOW_newExpression_in_newExpression3765);
                    newExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 10, newExpression_StartIndex); }
        }
        dbg.location(731, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "newExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "newExpression"


    // $ANTLR start "callExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:733:1: callExpression : memberExpression ( LineTerminator )* argumentList ( ( LineTerminator )* callExpressionSuffix )* ;
    public final void callExpression() throws RecognitionException {
        int callExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "callExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(733, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 11) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:2: ( memberExpression ( LineTerminator )* argumentList ( ( LineTerminator )* callExpressionSuffix )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:4: memberExpression ( LineTerminator )* argumentList ( ( LineTerminator )* callExpressionSuffix )*
            {
            dbg.location(734,4);
            pushFollow(FOLLOW_memberExpression_in_callExpression3777);
            memberExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(734,21);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:21: ( LineTerminator )*
            try { dbg.enterSubRule(31);

            loop31:
            do {
                int alt31=2;
                try { dbg.enterDecision(31);

                int LA31_0 = input.LA(1);

                if ( (LA31_0==LineTerminator) ) {
                    alt31=1;
                }


                } finally {dbg.exitDecision(31);}

                switch (alt31) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(734,21);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_callExpression3779); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop31;
                }
            } while (true);
            } finally {dbg.exitSubRule(31);}

            dbg.location(734,37);
            pushFollow(FOLLOW_argumentList_in_callExpression3782);
            argumentList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(734,50);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:50: ( ( LineTerminator )* callExpressionSuffix )*
            try { dbg.enterSubRule(33);

            loop33:
            do {
                int alt33=2;
                try { dbg.enterDecision(33);

                try {
                    isCyclicDecision = true;
                    alt33 = dfa33.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(33);}

                switch (alt33) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:51: ( LineTerminator )* callExpressionSuffix
            	    {
            	    dbg.location(734,51);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:51: ( LineTerminator )*
            	    try { dbg.enterSubRule(32);

            	    loop32:
            	    do {
            	        int alt32=2;
            	        try { dbg.enterDecision(32);

            	        int LA32_0 = input.LA(1);

            	        if ( (LA32_0==LineTerminator) ) {
            	            alt32=1;
            	        }


            	        } finally {dbg.exitDecision(32);}

            	        switch (alt32) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(734,51);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_callExpression3785); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop32;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(32);}

            	    dbg.location(734,67);
            	    pushFollow(FOLLOW_callExpressionSuffix_in_callExpression3788);
            	    callExpressionSuffix();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop33;
                }
            } while (true);
            } finally {dbg.exitSubRule(33);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 11, callExpression_StartIndex); }
        }
        dbg.location(735, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "callExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "callExpression"


    // $ANTLR start "callExpressionSuffix"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:737:1: callExpressionSuffix : ( argumentList | indexSuffix | propertyReferenceSuffix );
    public final void callExpressionSuffix() throws RecognitionException {
        int callExpressionSuffix_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "callExpressionSuffix");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(737, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 12) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:738:2: ( argumentList | indexSuffix | propertyReferenceSuffix )
            int alt34=3;
            try { dbg.enterDecision(34);

            switch ( input.LA(1) ) {
            case 36:
                {
                alt34=1;
                }
                break;
            case 38:
                {
                alt34=2;
                }
                break;
            case 45:
                {
                alt34=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 34, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(34);}

            switch (alt34) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:738:4: argumentList
                    {
                    dbg.location(738,4);
                    pushFollow(FOLLOW_argumentList_in_callExpressionSuffix3802);
                    argumentList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:739:4: indexSuffix
                    {
                    dbg.location(739,4);
                    pushFollow(FOLLOW_indexSuffix_in_callExpressionSuffix3807);
                    indexSuffix();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:740:4: propertyReferenceSuffix
                    {
                    dbg.location(740,4);
                    pushFollow(FOLLOW_propertyReferenceSuffix_in_callExpressionSuffix3812);
                    propertyReferenceSuffix();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 12, callExpressionSuffix_StartIndex); }
        }
        dbg.location(741, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "callExpressionSuffix");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "callExpressionSuffix"


    // $ANTLR start "indexSuffix"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:743:1: indexSuffix : '[' ( LineTerminator )* expression ( LineTerminator )* ']' ;
    public final void indexSuffix() throws RecognitionException {
        int indexSuffix_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "indexSuffix");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(743, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 13) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:744:2: ( '[' ( LineTerminator )* expression ( LineTerminator )* ']' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:744:4: '[' ( LineTerminator )* expression ( LineTerminator )* ']'
            {
            dbg.location(744,4);
            match(input,38,FOLLOW_38_in_indexSuffix3823); if (state.failed) return ;
            dbg.location(744,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:744:8: ( LineTerminator )*
            try { dbg.enterSubRule(35);

            loop35:
            do {
                int alt35=2;
                try { dbg.enterDecision(35);

                int LA35_0 = input.LA(1);

                if ( (LA35_0==LineTerminator) ) {
                    alt35=1;
                }


                } finally {dbg.exitDecision(35);}

                switch (alt35) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(744,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_indexSuffix3825); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop35;
                }
            } while (true);
            } finally {dbg.exitSubRule(35);}

            dbg.location(744,24);
            pushFollow(FOLLOW_expression_in_indexSuffix3828);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(744,35);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:744:35: ( LineTerminator )*
            try { dbg.enterSubRule(36);

            loop36:
            do {
                int alt36=2;
                try { dbg.enterDecision(36);

                int LA36_0 = input.LA(1);

                if ( (LA36_0==LineTerminator) ) {
                    alt36=1;
                }


                } finally {dbg.exitDecision(36);}

                switch (alt36) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(744,35);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_indexSuffix3830); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop36;
                }
            } while (true);
            } finally {dbg.exitSubRule(36);}

            dbg.location(744,51);
            match(input,40,FOLLOW_40_in_indexSuffix3833); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 13, indexSuffix_StartIndex); }
        }
        dbg.location(745, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "indexSuffix");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "indexSuffix"


    // $ANTLR start "propertyReferenceSuffix"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:747:1: propertyReferenceSuffix : '.' ( LineTerminator )* ( Identifier '::' ( LineTerminator )* )? Identifier ;
    public final void propertyReferenceSuffix() throws RecognitionException {
        int propertyReferenceSuffix_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "propertyReferenceSuffix");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(747, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 14) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:748:2: ( '.' ( LineTerminator )* ( Identifier '::' ( LineTerminator )* )? Identifier )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:748:4: '.' ( LineTerminator )* ( Identifier '::' ( LineTerminator )* )? Identifier
            {
            dbg.location(748,4);
            match(input,45,FOLLOW_45_in_propertyReferenceSuffix3846); if (state.failed) return ;
            dbg.location(748,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:748:8: ( LineTerminator )*
            try { dbg.enterSubRule(37);

            loop37:
            do {
                int alt37=2;
                try { dbg.enterDecision(37);

                int LA37_0 = input.LA(1);

                if ( (LA37_0==LineTerminator) ) {
                    alt37=1;
                }


                } finally {dbg.exitDecision(37);}

                switch (alt37) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(748,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_propertyReferenceSuffix3848); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop37;
                }
            } while (true);
            } finally {dbg.exitSubRule(37);}

            dbg.location(748,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:748:24: ( Identifier '::' ( LineTerminator )* )?
            int alt39=2;
            try { dbg.enterSubRule(39);
            try { dbg.enterDecision(39);

            int LA39_0 = input.LA(1);

            if ( (LA39_0==Identifier) ) {
                int LA39_1 = input.LA(2);

                if ( (LA39_1==46) ) {
                    alt39=1;
                }
            }
            } finally {dbg.exitDecision(39);}

            switch (alt39) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:748:25: Identifier '::' ( LineTerminator )*
                    {
                    dbg.location(748,25);
                    match(input,Identifier,FOLLOW_Identifier_in_propertyReferenceSuffix3852); if (state.failed) return ;
                    dbg.location(748,36);
                    match(input,46,FOLLOW_46_in_propertyReferenceSuffix3854); if (state.failed) return ;
                    dbg.location(748,41);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:748:41: ( LineTerminator )*
                    try { dbg.enterSubRule(38);

                    loop38:
                    do {
                        int alt38=2;
                        try { dbg.enterDecision(38);

                        int LA38_0 = input.LA(1);

                        if ( (LA38_0==LineTerminator) ) {
                            alt38=1;
                        }


                        } finally {dbg.exitDecision(38);}

                        switch (alt38) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(748,41);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_propertyReferenceSuffix3856); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop38;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(38);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(39);}

            dbg.location(748,59);
            match(input,Identifier,FOLLOW_Identifier_in_propertyReferenceSuffix3861); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 14, propertyReferenceSuffix_StartIndex); }
        }
        dbg.location(749, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "propertyReferenceSuffix");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "propertyReferenceSuffix"


    // $ANTLR start "argumentList"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:751:1: argumentList : '(' ( ( LineTerminator )* assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )* )? ( LineTerminator )* ')' ;
    public final void argumentList() throws RecognitionException {
        int argumentList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "argumentList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(751, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 15) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:2: ( '(' ( ( LineTerminator )* assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )* )? ( LineTerminator )* ')' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:4: '(' ( ( LineTerminator )* assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )* )? ( LineTerminator )* ')'
            {
            dbg.location(752,4);
            match(input,36,FOLLOW_36_in_argumentList3873); if (state.failed) return ;
            dbg.location(752,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:8: ( ( LineTerminator )* assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )* )?
            int alt44=2;
            try { dbg.enterSubRule(44);
            try { dbg.enterDecision(44);

            try {
                isCyclicDecision = true;
                alt44 = dfa44.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(44);}

            switch (alt44) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:9: ( LineTerminator )* assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )*
                    {
                    dbg.location(752,9);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:9: ( LineTerminator )*
                    try { dbg.enterSubRule(40);

                    loop40:
                    do {
                        int alt40=2;
                        try { dbg.enterDecision(40);

                        int LA40_0 = input.LA(1);

                        if ( (LA40_0==LineTerminator) ) {
                            alt40=1;
                        }


                        } finally {dbg.exitDecision(40);}

                        switch (alt40) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(752,9);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_argumentList3876); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop40;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(40);}

                    dbg.location(752,25);
                    pushFollow(FOLLOW_assignmentExpression_in_argumentList3879);
                    assignmentExpression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(752,46);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:46: ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )*
                    try { dbg.enterSubRule(43);

                    loop43:
                    do {
                        int alt43=2;
                        try { dbg.enterDecision(43);

                        try {
                            isCyclicDecision = true;
                            alt43 = dfa43.predict(input);
                        }
                        catch (NoViableAltException nvae) {
                            dbg.recognitionException(nvae);
                            throw nvae;
                        }
                        } finally {dbg.exitDecision(43);}

                        switch (alt43) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:47: ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression
                    	    {
                    	    dbg.location(752,47);
                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:47: ( LineTerminator )*
                    	    try { dbg.enterSubRule(41);

                    	    loop41:
                    	    do {
                    	        int alt41=2;
                    	        try { dbg.enterDecision(41);

                    	        int LA41_0 = input.LA(1);

                    	        if ( (LA41_0==LineTerminator) ) {
                    	            alt41=1;
                    	        }


                    	        } finally {dbg.exitDecision(41);}

                    	        switch (alt41) {
                    	    	case 1 :
                    	    	    dbg.enterAlt(1);

                    	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    	    {
                    	    	    dbg.location(752,47);
                    	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_argumentList3882); if (state.failed) return ;

                    	    	    }
                    	    	    break;

                    	    	default :
                    	    	    break loop41;
                    	        }
                    	    } while (true);
                    	    } finally {dbg.exitSubRule(41);}

                    	    dbg.location(752,63);
                    	    match(input,39,FOLLOW_39_in_argumentList3885); if (state.failed) return ;
                    	    dbg.location(752,67);
                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:67: ( LineTerminator )*
                    	    try { dbg.enterSubRule(42);

                    	    loop42:
                    	    do {
                    	        int alt42=2;
                    	        try { dbg.enterDecision(42);

                    	        int LA42_0 = input.LA(1);

                    	        if ( (LA42_0==LineTerminator) ) {
                    	            alt42=1;
                    	        }


                    	        } finally {dbg.exitDecision(42);}

                    	        switch (alt42) {
                    	    	case 1 :
                    	    	    dbg.enterAlt(1);

                    	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    	    {
                    	    	    dbg.location(752,67);
                    	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_argumentList3887); if (state.failed) return ;

                    	    	    }
                    	    	    break;

                    	    	default :
                    	    	    break loop42;
                    	        }
                    	    } while (true);
                    	    } finally {dbg.exitSubRule(42);}

                    	    dbg.location(752,83);
                    	    pushFollow(FOLLOW_assignmentExpression_in_argumentList3890);
                    	    assignmentExpression();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop43;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(43);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(44);}

            dbg.location(752,108);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:752:108: ( LineTerminator )*
            try { dbg.enterSubRule(45);

            loop45:
            do {
                int alt45=2;
                try { dbg.enterDecision(45);

                int LA45_0 = input.LA(1);

                if ( (LA45_0==LineTerminator) ) {
                    alt45=1;
                }


                } finally {dbg.exitDecision(45);}

                switch (alt45) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(752,108);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_argumentList3896); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop45;
                }
            } while (true);
            } finally {dbg.exitSubRule(45);}

            dbg.location(752,124);
            match(input,37,FOLLOW_37_in_argumentList3899); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 15, argumentList_StartIndex); }
        }
        dbg.location(753, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "argumentList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "argumentList"


    // $ANTLR start "leftHandSideExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:755:1: leftHandSideExpression : ( callExpression | newExpression );
    public final void leftHandSideExpression() throws RecognitionException {
        int leftHandSideExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "leftHandSideExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(755, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 16) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:756:2: ( callExpression | newExpression )
            int alt46=2;
            try { dbg.enterDecision(46);

            try {
                isCyclicDecision = true;
                alt46 = dfa46.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(46);}

            switch (alt46) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:756:4: callExpression
                    {
                    dbg.location(756,4);
                    pushFollow(FOLLOW_callExpression_in_leftHandSideExpression3911);
                    callExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:757:4: newExpression
                    {
                    dbg.location(757,4);
                    pushFollow(FOLLOW_newExpression_in_leftHandSideExpression3916);
                    newExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 16, leftHandSideExpression_StartIndex); }
        }
        dbg.location(758, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "leftHandSideExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "leftHandSideExpression"


    // $ANTLR start "postfixExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:760:1: postfixExpression : ( leftHandSideExpression '++' | leftHandSideExpression '--' | leftHandSideExpression );
    public final void postfixExpression() throws RecognitionException {
        int postfixExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "postfixExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(760, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 17) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:761:2: ( leftHandSideExpression '++' | leftHandSideExpression '--' | leftHandSideExpression )
            int alt47=3;
            try { dbg.enterDecision(47);

            try {
                isCyclicDecision = true;
                alt47 = dfa47.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(47);}

            switch (alt47) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:761:4: leftHandSideExpression '++'
                    {
                    dbg.location(761,4);
                    pushFollow(FOLLOW_leftHandSideExpression_in_postfixExpression3927);
                    leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(761,27);
                    match(input,47,FOLLOW_47_in_postfixExpression3929); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:762:4: leftHandSideExpression '--'
                    {
                    dbg.location(762,4);
                    pushFollow(FOLLOW_leftHandSideExpression_in_postfixExpression3934);
                    leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(762,27);
                    match(input,48,FOLLOW_48_in_postfixExpression3936); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:763:4: leftHandSideExpression
                    {
                    dbg.location(763,4);
                    pushFollow(FOLLOW_leftHandSideExpression_in_postfixExpression3941);
                    leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 17, postfixExpression_StartIndex); }
        }
        dbg.location(764, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "postfixExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "postfixExpression"


    // $ANTLR start "unaryExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:766:1: unaryExpression : ( postfixExpression | ( 'delete' | 'void' | 'typeof' | 'as' | '++' | '--' | '+' | '-' | '~' | '!' ) unaryExpression );
    public final void unaryExpression() throws RecognitionException {
        int unaryExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "unaryExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(766, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 18) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:767:2: ( postfixExpression | ( 'delete' | 'void' | 'typeof' | 'as' | '++' | '--' | '+' | '-' | '~' | '!' ) unaryExpression )
            int alt48=2;
            try { dbg.enterDecision(48);

            int LA48_0 = input.LA(1);

            if ( (LA48_0==Identifier||(LA48_0>=NullLiteral && LA48_0<=StringLiteral)||(LA48_0>=34 && LA48_0<=36)||LA48_0==38||LA48_0==41||LA48_0==44||LA48_0==111) ) {
                alt48=1;
            }
            else if ( ((LA48_0>=47 && LA48_0<=56)) ) {
                alt48=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 48, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(48);}

            switch (alt48) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:767:4: postfixExpression
                    {
                    dbg.location(767,4);
                    pushFollow(FOLLOW_postfixExpression_in_unaryExpression3952);
                    postfixExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:768:4: ( 'delete' | 'void' | 'typeof' | 'as' | '++' | '--' | '+' | '-' | '~' | '!' ) unaryExpression
                    {
                    dbg.location(768,4);
                    if ( (input.LA(1)>=47 && input.LA(1)<=56) ) {
                        input.consume();
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }

                    dbg.location(768,80);
                    pushFollow(FOLLOW_unaryExpression_in_unaryExpression3997);
                    unaryExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 18, unaryExpression_StartIndex); }
        }
        dbg.location(769, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "unaryExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "unaryExpression"


    // $ANTLR start "multiplicativeExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:771:1: multiplicativeExpression : unaryExpression ( ( LineTerminator )* ( '*' | '/' | '%' ) ( LineTerminator )* unaryExpression )* ;
    public final void multiplicativeExpression() throws RecognitionException {
        int multiplicativeExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "multiplicativeExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(771, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 19) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:772:2: ( unaryExpression ( ( LineTerminator )* ( '*' | '/' | '%' ) ( LineTerminator )* unaryExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:772:4: unaryExpression ( ( LineTerminator )* ( '*' | '/' | '%' ) ( LineTerminator )* unaryExpression )*
            {
            dbg.location(772,4);
            pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4008);
            unaryExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(772,20);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:772:20: ( ( LineTerminator )* ( '*' | '/' | '%' ) ( LineTerminator )* unaryExpression )*
            try { dbg.enterSubRule(51);

            loop51:
            do {
                int alt51=2;
                try { dbg.enterDecision(51);

                try {
                    isCyclicDecision = true;
                    alt51 = dfa51.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(51);}

                switch (alt51) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:772:21: ( LineTerminator )* ( '*' | '/' | '%' ) ( LineTerminator )* unaryExpression
            	    {
            	    dbg.location(772,21);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:772:21: ( LineTerminator )*
            	    try { dbg.enterSubRule(49);

            	    loop49:
            	    do {
            	        int alt49=2;
            	        try { dbg.enterDecision(49);

            	        int LA49_0 = input.LA(1);

            	        if ( (LA49_0==LineTerminator) ) {
            	            alt49=1;
            	        }


            	        } finally {dbg.exitDecision(49);}

            	        switch (alt49) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(772,21);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_multiplicativeExpression4011); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop49;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(49);}

            	    dbg.location(772,37);
            	    if ( (input.LA(1)>=57 && input.LA(1)<=59) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(772,55);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:772:55: ( LineTerminator )*
            	    try { dbg.enterSubRule(50);

            	    loop50:
            	    do {
            	        int alt50=2;
            	        try { dbg.enterDecision(50);

            	        int LA50_0 = input.LA(1);

            	        if ( (LA50_0==LineTerminator) ) {
            	            alt50=1;
            	        }


            	        } finally {dbg.exitDecision(50);}

            	        switch (alt50) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(772,55);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_multiplicativeExpression4026); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop50;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(50);}

            	    dbg.location(772,71);
            	    pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4029);
            	    unaryExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop51;
                }
            } while (true);
            } finally {dbg.exitSubRule(51);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 19, multiplicativeExpression_StartIndex); }
        }
        dbg.location(773, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "multiplicativeExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "multiplicativeExpression"


    // $ANTLR start "additiveExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:775:1: additiveExpression : multiplicativeExpression ( ( LineTerminator )* ( '+' | '-' ) ( LineTerminator )* multiplicativeExpression )* ;
    public final void additiveExpression() throws RecognitionException {
        int additiveExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "additiveExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(775, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 20) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:2: ( multiplicativeExpression ( ( LineTerminator )* ( '+' | '-' ) ( LineTerminator )* multiplicativeExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:4: multiplicativeExpression ( ( LineTerminator )* ( '+' | '-' ) ( LineTerminator )* multiplicativeExpression )*
            {
            dbg.location(776,4);
            pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4042);
            multiplicativeExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(776,29);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:29: ( ( LineTerminator )* ( '+' | '-' ) ( LineTerminator )* multiplicativeExpression )*
            try { dbg.enterSubRule(54);

            loop54:
            do {
                int alt54=2;
                try { dbg.enterDecision(54);

                try {
                    isCyclicDecision = true;
                    alt54 = dfa54.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(54);}

                switch (alt54) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:30: ( LineTerminator )* ( '+' | '-' ) ( LineTerminator )* multiplicativeExpression
            	    {
            	    dbg.location(776,30);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:30: ( LineTerminator )*
            	    try { dbg.enterSubRule(52);

            	    loop52:
            	    do {
            	        int alt52=2;
            	        try { dbg.enterDecision(52);

            	        int LA52_0 = input.LA(1);

            	        if ( (LA52_0==LineTerminator) ) {
            	            alt52=1;
            	        }


            	        } finally {dbg.exitDecision(52);}

            	        switch (alt52) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(776,30);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_additiveExpression4045); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop52;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(52);}

            	    dbg.location(776,46);
            	    if ( (input.LA(1)>=53 && input.LA(1)<=54) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(776,58);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:58: ( LineTerminator )*
            	    try { dbg.enterSubRule(53);

            	    loop53:
            	    do {
            	        int alt53=2;
            	        try { dbg.enterDecision(53);

            	        int LA53_0 = input.LA(1);

            	        if ( (LA53_0==LineTerminator) ) {
            	            alt53=1;
            	        }


            	        } finally {dbg.exitDecision(53);}

            	        switch (alt53) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(776,58);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_additiveExpression4056); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop53;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(53);}

            	    dbg.location(776,74);
            	    pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4059);
            	    multiplicativeExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop54;
                }
            } while (true);
            } finally {dbg.exitSubRule(54);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 20, additiveExpression_StartIndex); }
        }
        dbg.location(777, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "additiveExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "additiveExpression"


    // $ANTLR start "shiftExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:779:1: shiftExpression : additiveExpression ( ( LineTerminator )* ( '<<' | '>>' | '>>>' ) ( LineTerminator )* additiveExpression )* ;
    public final void shiftExpression() throws RecognitionException {
        int shiftExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "shiftExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(779, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 21) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:780:2: ( additiveExpression ( ( LineTerminator )* ( '<<' | '>>' | '>>>' ) ( LineTerminator )* additiveExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:780:4: additiveExpression ( ( LineTerminator )* ( '<<' | '>>' | '>>>' ) ( LineTerminator )* additiveExpression )*
            {
            dbg.location(780,4);
            pushFollow(FOLLOW_additiveExpression_in_shiftExpression4072);
            additiveExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(780,23);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:780:23: ( ( LineTerminator )* ( '<<' | '>>' | '>>>' ) ( LineTerminator )* additiveExpression )*
            try { dbg.enterSubRule(57);

            loop57:
            do {
                int alt57=2;
                try { dbg.enterDecision(57);

                try {
                    isCyclicDecision = true;
                    alt57 = dfa57.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(57);}

                switch (alt57) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:780:24: ( LineTerminator )* ( '<<' | '>>' | '>>>' ) ( LineTerminator )* additiveExpression
            	    {
            	    dbg.location(780,24);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:780:24: ( LineTerminator )*
            	    try { dbg.enterSubRule(55);

            	    loop55:
            	    do {
            	        int alt55=2;
            	        try { dbg.enterDecision(55);

            	        int LA55_0 = input.LA(1);

            	        if ( (LA55_0==LineTerminator) ) {
            	            alt55=1;
            	        }


            	        } finally {dbg.exitDecision(55);}

            	        switch (alt55) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(780,24);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_shiftExpression4075); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop55;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(55);}

            	    dbg.location(780,40);
            	    if ( (input.LA(1)>=60 && input.LA(1)<=62) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(780,62);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:780:62: ( LineTerminator )*
            	    try { dbg.enterSubRule(56);

            	    loop56:
            	    do {
            	        int alt56=2;
            	        try { dbg.enterDecision(56);

            	        int LA56_0 = input.LA(1);

            	        if ( (LA56_0==LineTerminator) ) {
            	            alt56=1;
            	        }


            	        } finally {dbg.exitDecision(56);}

            	        switch (alt56) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(780,62);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_shiftExpression4090); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop56;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(56);}

            	    dbg.location(780,78);
            	    pushFollow(FOLLOW_additiveExpression_in_shiftExpression4093);
            	    additiveExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop57;
                }
            } while (true);
            } finally {dbg.exitSubRule(57);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 21, shiftExpression_StartIndex); }
        }
        dbg.location(781, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "shiftExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "shiftExpression"


    // $ANTLR start "relationalExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:783:1: relationalExpression : shiftExpression ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' | 'in' ) ( LineTerminator )* shiftExpression )* ;
    public final void relationalExpression() throws RecognitionException {
        int relationalExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "relationalExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(783, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 22) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:2: ( shiftExpression ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' | 'in' ) ( LineTerminator )* shiftExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:4: shiftExpression ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' | 'in' ) ( LineTerminator )* shiftExpression )*
            {
            dbg.location(784,4);
            pushFollow(FOLLOW_shiftExpression_in_relationalExpression4106);
            shiftExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(784,20);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:20: ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' | 'in' ) ( LineTerminator )* shiftExpression )*
            try { dbg.enterSubRule(60);

            loop60:
            do {
                int alt60=2;
                try { dbg.enterDecision(60);

                try {
                    isCyclicDecision = true;
                    alt60 = dfa60.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(60);}

                switch (alt60) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:21: ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' | 'in' ) ( LineTerminator )* shiftExpression
            	    {
            	    dbg.location(784,21);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:21: ( LineTerminator )*
            	    try { dbg.enterSubRule(58);

            	    loop58:
            	    do {
            	        int alt58=2;
            	        try { dbg.enterDecision(58);

            	        int LA58_0 = input.LA(1);

            	        if ( (LA58_0==LineTerminator) ) {
            	            alt58=1;
            	        }


            	        } finally {dbg.exitDecision(58);}

            	        switch (alt58) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(784,21);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_relationalExpression4109); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop58;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(58);}

            	    dbg.location(784,37);
            	    if ( (input.LA(1)>=63 && input.LA(1)<=69) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(784,92);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:92: ( LineTerminator )*
            	    try { dbg.enterSubRule(59);

            	    loop59:
            	    do {
            	        int alt59=2;
            	        try { dbg.enterDecision(59);

            	        int LA59_0 = input.LA(1);

            	        if ( (LA59_0==LineTerminator) ) {
            	            alt59=1;
            	        }


            	        } finally {dbg.exitDecision(59);}

            	        switch (alt59) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(784,92);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_relationalExpression4140); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop59;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(59);}

            	    dbg.location(784,108);
            	    pushFollow(FOLLOW_shiftExpression_in_relationalExpression4143);
            	    shiftExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop60;
                }
            } while (true);
            } finally {dbg.exitSubRule(60);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 22, relationalExpression_StartIndex); }
        }
        dbg.location(785, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "relationalExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "relationalExpression"


    // $ANTLR start "relationalExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:787:1: relationalExpressionNoIn : shiftExpression ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' ) ( LineTerminator )* shiftExpression )* ;
    public final void relationalExpressionNoIn() throws RecognitionException {
        int relationalExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "relationalExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(787, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 23) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:788:2: ( shiftExpression ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' ) ( LineTerminator )* shiftExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:788:4: shiftExpression ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' ) ( LineTerminator )* shiftExpression )*
            {
            dbg.location(788,4);
            pushFollow(FOLLOW_shiftExpression_in_relationalExpressionNoIn4157);
            shiftExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(788,20);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:788:20: ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' ) ( LineTerminator )* shiftExpression )*
            try { dbg.enterSubRule(63);

            loop63:
            do {
                int alt63=2;
                try { dbg.enterDecision(63);

                try {
                    isCyclicDecision = true;
                    alt63 = dfa63.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(63);}

                switch (alt63) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:788:21: ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' ) ( LineTerminator )* shiftExpression
            	    {
            	    dbg.location(788,21);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:788:21: ( LineTerminator )*
            	    try { dbg.enterSubRule(61);

            	    loop61:
            	    do {
            	        int alt61=2;
            	        try { dbg.enterDecision(61);

            	        int LA61_0 = input.LA(1);

            	        if ( (LA61_0==LineTerminator) ) {
            	            alt61=1;
            	        }


            	        } finally {dbg.exitDecision(61);}

            	        switch (alt61) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(788,21);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_relationalExpressionNoIn4160); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop61;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(61);}

            	    dbg.location(788,37);
            	    if ( (input.LA(1)>=63 && input.LA(1)<=68) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(788,85);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:788:85: ( LineTerminator )*
            	    try { dbg.enterSubRule(62);

            	    loop62:
            	    do {
            	        int alt62=2;
            	        try { dbg.enterDecision(62);

            	        int LA62_0 = input.LA(1);

            	        if ( (LA62_0==LineTerminator) ) {
            	            alt62=1;
            	        }


            	        } finally {dbg.exitDecision(62);}

            	        switch (alt62) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(788,85);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_relationalExpressionNoIn4187); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop62;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(62);}

            	    dbg.location(788,101);
            	    pushFollow(FOLLOW_shiftExpression_in_relationalExpressionNoIn4190);
            	    shiftExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop63;
                }
            } while (true);
            } finally {dbg.exitSubRule(63);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 23, relationalExpressionNoIn_StartIndex); }
        }
        dbg.location(789, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "relationalExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "relationalExpressionNoIn"


    // $ANTLR start "equalityExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:791:1: equalityExpression : relationalExpression ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpression )* ;
    public final void equalityExpression() throws RecognitionException {
        int equalityExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "equalityExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(791, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 24) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:792:2: ( relationalExpression ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:792:4: relationalExpression ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpression )*
            {
            dbg.location(792,4);
            pushFollow(FOLLOW_relationalExpression_in_equalityExpression4204);
            relationalExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(792,25);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:792:25: ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpression )*
            try { dbg.enterSubRule(66);

            loop66:
            do {
                int alt66=2;
                try { dbg.enterDecision(66);

                try {
                    isCyclicDecision = true;
                    alt66 = dfa66.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(66);}

                switch (alt66) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:792:26: ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpression
            	    {
            	    dbg.location(792,26);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:792:26: ( LineTerminator )*
            	    try { dbg.enterSubRule(64);

            	    loop64:
            	    do {
            	        int alt64=2;
            	        try { dbg.enterDecision(64);

            	        int LA64_0 = input.LA(1);

            	        if ( (LA64_0==LineTerminator) ) {
            	            alt64=1;
            	        }


            	        } finally {dbg.exitDecision(64);}

            	        switch (alt64) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(792,26);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_equalityExpression4207); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop64;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(64);}

            	    dbg.location(792,42);
            	    if ( (input.LA(1)>=70 && input.LA(1)<=73) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(792,72);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:792:72: ( LineTerminator )*
            	    try { dbg.enterSubRule(65);

            	    loop65:
            	    do {
            	        int alt65=2;
            	        try { dbg.enterDecision(65);

            	        int LA65_0 = input.LA(1);

            	        if ( (LA65_0==LineTerminator) ) {
            	            alt65=1;
            	        }


            	        } finally {dbg.exitDecision(65);}

            	        switch (alt65) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(792,72);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_equalityExpression4226); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop65;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(65);}

            	    dbg.location(792,88);
            	    pushFollow(FOLLOW_relationalExpression_in_equalityExpression4229);
            	    relationalExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop66;
                }
            } while (true);
            } finally {dbg.exitSubRule(66);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 24, equalityExpression_StartIndex); }
        }
        dbg.location(793, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "equalityExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "equalityExpression"


    // $ANTLR start "equalityExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:795:1: equalityExpressionNoIn : relationalExpressionNoIn ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpressionNoIn )* ;
    public final void equalityExpressionNoIn() throws RecognitionException {
        int equalityExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "equalityExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(795, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 25) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:796:2: ( relationalExpressionNoIn ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpressionNoIn )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:796:4: relationalExpressionNoIn ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpressionNoIn )*
            {
            dbg.location(796,4);
            pushFollow(FOLLOW_relationalExpressionNoIn_in_equalityExpressionNoIn4242);
            relationalExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(796,29);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:796:29: ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpressionNoIn )*
            try { dbg.enterSubRule(69);

            loop69:
            do {
                int alt69=2;
                try { dbg.enterDecision(69);

                try {
                    isCyclicDecision = true;
                    alt69 = dfa69.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(69);}

                switch (alt69) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:796:30: ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpressionNoIn
            	    {
            	    dbg.location(796,30);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:796:30: ( LineTerminator )*
            	    try { dbg.enterSubRule(67);

            	    loop67:
            	    do {
            	        int alt67=2;
            	        try { dbg.enterDecision(67);

            	        int LA67_0 = input.LA(1);

            	        if ( (LA67_0==LineTerminator) ) {
            	            alt67=1;
            	        }


            	        } finally {dbg.exitDecision(67);}

            	        switch (alt67) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(796,30);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_equalityExpressionNoIn4245); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop67;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(67);}

            	    dbg.location(796,46);
            	    if ( (input.LA(1)>=70 && input.LA(1)<=73) ) {
            	        input.consume();
            	        state.errorRecovery=false;state.failed=false;
            	    }
            	    else {
            	        if (state.backtracking>0) {state.failed=true; return ;}
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        dbg.recognitionException(mse);
            	        throw mse;
            	    }

            	    dbg.location(796,76);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:796:76: ( LineTerminator )*
            	    try { dbg.enterSubRule(68);

            	    loop68:
            	    do {
            	        int alt68=2;
            	        try { dbg.enterDecision(68);

            	        int LA68_0 = input.LA(1);

            	        if ( (LA68_0==LineTerminator) ) {
            	            alt68=1;
            	        }


            	        } finally {dbg.exitDecision(68);}

            	        switch (alt68) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(796,76);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_equalityExpressionNoIn4264); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop68;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(68);}

            	    dbg.location(796,92);
            	    pushFollow(FOLLOW_relationalExpressionNoIn_in_equalityExpressionNoIn4267);
            	    relationalExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop69;
                }
            } while (true);
            } finally {dbg.exitSubRule(69);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 25, equalityExpressionNoIn_StartIndex); }
        }
        dbg.location(797, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "equalityExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "equalityExpressionNoIn"


    // $ANTLR start "bitwiseANDExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:799:1: bitwiseANDExpression : equalityExpression ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpression )* ;
    public final void bitwiseANDExpression() throws RecognitionException {
        int bitwiseANDExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "bitwiseANDExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(799, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 26) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:800:2: ( equalityExpression ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:800:4: equalityExpression ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpression )*
            {
            dbg.location(800,4);
            pushFollow(FOLLOW_equalityExpression_in_bitwiseANDExpression4280);
            equalityExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(800,23);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:800:23: ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpression )*
            try { dbg.enterSubRule(72);

            loop72:
            do {
                int alt72=2;
                try { dbg.enterDecision(72);

                try {
                    isCyclicDecision = true;
                    alt72 = dfa72.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(72);}

                switch (alt72) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:800:24: ( LineTerminator )* '&' ( LineTerminator )* equalityExpression
            	    {
            	    dbg.location(800,24);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:800:24: ( LineTerminator )*
            	    try { dbg.enterSubRule(70);

            	    loop70:
            	    do {
            	        int alt70=2;
            	        try { dbg.enterDecision(70);

            	        int LA70_0 = input.LA(1);

            	        if ( (LA70_0==LineTerminator) ) {
            	            alt70=1;
            	        }


            	        } finally {dbg.exitDecision(70);}

            	        switch (alt70) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(800,24);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseANDExpression4283); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop70;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(70);}

            	    dbg.location(800,40);
            	    match(input,74,FOLLOW_74_in_bitwiseANDExpression4286); if (state.failed) return ;
            	    dbg.location(800,44);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:800:44: ( LineTerminator )*
            	    try { dbg.enterSubRule(71);

            	    loop71:
            	    do {
            	        int alt71=2;
            	        try { dbg.enterDecision(71);

            	        int LA71_0 = input.LA(1);

            	        if ( (LA71_0==LineTerminator) ) {
            	            alt71=1;
            	        }


            	        } finally {dbg.exitDecision(71);}

            	        switch (alt71) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(800,44);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseANDExpression4288); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop71;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(71);}

            	    dbg.location(800,60);
            	    pushFollow(FOLLOW_equalityExpression_in_bitwiseANDExpression4291);
            	    equalityExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop72;
                }
            } while (true);
            } finally {dbg.exitSubRule(72);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 26, bitwiseANDExpression_StartIndex); }
        }
        dbg.location(801, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "bitwiseANDExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "bitwiseANDExpression"


    // $ANTLR start "bitwiseANDExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:803:1: bitwiseANDExpressionNoIn : equalityExpressionNoIn ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpressionNoIn )* ;
    public final void bitwiseANDExpressionNoIn() throws RecognitionException {
        int bitwiseANDExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "bitwiseANDExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(803, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 27) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:804:2: ( equalityExpressionNoIn ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpressionNoIn )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:804:4: equalityExpressionNoIn ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpressionNoIn )*
            {
            dbg.location(804,4);
            pushFollow(FOLLOW_equalityExpressionNoIn_in_bitwiseANDExpressionNoIn4305);
            equalityExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(804,27);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:804:27: ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpressionNoIn )*
            try { dbg.enterSubRule(75);

            loop75:
            do {
                int alt75=2;
                try { dbg.enterDecision(75);

                try {
                    isCyclicDecision = true;
                    alt75 = dfa75.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(75);}

                switch (alt75) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:804:28: ( LineTerminator )* '&' ( LineTerminator )* equalityExpressionNoIn
            	    {
            	    dbg.location(804,28);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:804:28: ( LineTerminator )*
            	    try { dbg.enterSubRule(73);

            	    loop73:
            	    do {
            	        int alt73=2;
            	        try { dbg.enterDecision(73);

            	        int LA73_0 = input.LA(1);

            	        if ( (LA73_0==LineTerminator) ) {
            	            alt73=1;
            	        }


            	        } finally {dbg.exitDecision(73);}

            	        switch (alt73) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(804,28);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseANDExpressionNoIn4308); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop73;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(73);}

            	    dbg.location(804,44);
            	    match(input,74,FOLLOW_74_in_bitwiseANDExpressionNoIn4311); if (state.failed) return ;
            	    dbg.location(804,48);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:804:48: ( LineTerminator )*
            	    try { dbg.enterSubRule(74);

            	    loop74:
            	    do {
            	        int alt74=2;
            	        try { dbg.enterDecision(74);

            	        int LA74_0 = input.LA(1);

            	        if ( (LA74_0==LineTerminator) ) {
            	            alt74=1;
            	        }


            	        } finally {dbg.exitDecision(74);}

            	        switch (alt74) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(804,48);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseANDExpressionNoIn4313); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop74;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(74);}

            	    dbg.location(804,64);
            	    pushFollow(FOLLOW_equalityExpressionNoIn_in_bitwiseANDExpressionNoIn4316);
            	    equalityExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop75;
                }
            } while (true);
            } finally {dbg.exitSubRule(75);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 27, bitwiseANDExpressionNoIn_StartIndex); }
        }
        dbg.location(805, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "bitwiseANDExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "bitwiseANDExpressionNoIn"


    // $ANTLR start "bitwiseXORExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:807:1: bitwiseXORExpression : bitwiseANDExpression ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpression )* ;
    public final void bitwiseXORExpression() throws RecognitionException {
        int bitwiseXORExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "bitwiseXORExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(807, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 28) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:808:2: ( bitwiseANDExpression ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:808:4: bitwiseANDExpression ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpression )*
            {
            dbg.location(808,4);
            pushFollow(FOLLOW_bitwiseANDExpression_in_bitwiseXORExpression4329);
            bitwiseANDExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(808,25);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:808:25: ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpression )*
            try { dbg.enterSubRule(78);

            loop78:
            do {
                int alt78=2;
                try { dbg.enterDecision(78);

                try {
                    isCyclicDecision = true;
                    alt78 = dfa78.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(78);}

                switch (alt78) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:808:26: ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpression
            	    {
            	    dbg.location(808,26);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:808:26: ( LineTerminator )*
            	    try { dbg.enterSubRule(76);

            	    loop76:
            	    do {
            	        int alt76=2;
            	        try { dbg.enterDecision(76);

            	        int LA76_0 = input.LA(1);

            	        if ( (LA76_0==LineTerminator) ) {
            	            alt76=1;
            	        }


            	        } finally {dbg.exitDecision(76);}

            	        switch (alt76) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(808,26);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseXORExpression4332); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop76;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(76);}

            	    dbg.location(808,42);
            	    match(input,75,FOLLOW_75_in_bitwiseXORExpression4335); if (state.failed) return ;
            	    dbg.location(808,46);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:808:46: ( LineTerminator )*
            	    try { dbg.enterSubRule(77);

            	    loop77:
            	    do {
            	        int alt77=2;
            	        try { dbg.enterDecision(77);

            	        int LA77_0 = input.LA(1);

            	        if ( (LA77_0==LineTerminator) ) {
            	            alt77=1;
            	        }


            	        } finally {dbg.exitDecision(77);}

            	        switch (alt77) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(808,46);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseXORExpression4337); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop77;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(77);}

            	    dbg.location(808,62);
            	    pushFollow(FOLLOW_bitwiseANDExpression_in_bitwiseXORExpression4340);
            	    bitwiseANDExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop78;
                }
            } while (true);
            } finally {dbg.exitSubRule(78);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 28, bitwiseXORExpression_StartIndex); }
        }
        dbg.location(809, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "bitwiseXORExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "bitwiseXORExpression"


    // $ANTLR start "bitwiseXORExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:811:1: bitwiseXORExpressionNoIn : bitwiseANDExpressionNoIn ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpressionNoIn )* ;
    public final void bitwiseXORExpressionNoIn() throws RecognitionException {
        int bitwiseXORExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "bitwiseXORExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(811, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 29) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:812:2: ( bitwiseANDExpressionNoIn ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpressionNoIn )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:812:4: bitwiseANDExpressionNoIn ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpressionNoIn )*
            {
            dbg.location(812,4);
            pushFollow(FOLLOW_bitwiseANDExpressionNoIn_in_bitwiseXORExpressionNoIn4354);
            bitwiseANDExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(812,29);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:812:29: ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpressionNoIn )*
            try { dbg.enterSubRule(81);

            loop81:
            do {
                int alt81=2;
                try { dbg.enterDecision(81);

                try {
                    isCyclicDecision = true;
                    alt81 = dfa81.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(81);}

                switch (alt81) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:812:30: ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpressionNoIn
            	    {
            	    dbg.location(812,30);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:812:30: ( LineTerminator )*
            	    try { dbg.enterSubRule(79);

            	    loop79:
            	    do {
            	        int alt79=2;
            	        try { dbg.enterDecision(79);

            	        int LA79_0 = input.LA(1);

            	        if ( (LA79_0==LineTerminator) ) {
            	            alt79=1;
            	        }


            	        } finally {dbg.exitDecision(79);}

            	        switch (alt79) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(812,30);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseXORExpressionNoIn4357); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop79;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(79);}

            	    dbg.location(812,46);
            	    match(input,75,FOLLOW_75_in_bitwiseXORExpressionNoIn4360); if (state.failed) return ;
            	    dbg.location(812,50);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:812:50: ( LineTerminator )*
            	    try { dbg.enterSubRule(80);

            	    loop80:
            	    do {
            	        int alt80=2;
            	        try { dbg.enterDecision(80);

            	        int LA80_0 = input.LA(1);

            	        if ( (LA80_0==LineTerminator) ) {
            	            alt80=1;
            	        }


            	        } finally {dbg.exitDecision(80);}

            	        switch (alt80) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(812,50);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseXORExpressionNoIn4362); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop80;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(80);}

            	    dbg.location(812,66);
            	    pushFollow(FOLLOW_bitwiseANDExpressionNoIn_in_bitwiseXORExpressionNoIn4365);
            	    bitwiseANDExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop81;
                }
            } while (true);
            } finally {dbg.exitSubRule(81);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 29, bitwiseXORExpressionNoIn_StartIndex); }
        }
        dbg.location(813, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "bitwiseXORExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "bitwiseXORExpressionNoIn"


    // $ANTLR start "bitwiseORExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:815:1: bitwiseORExpression : bitwiseXORExpression ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpression )* ;
    public final void bitwiseORExpression() throws RecognitionException {
        int bitwiseORExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "bitwiseORExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(815, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 30) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:816:2: ( bitwiseXORExpression ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:816:4: bitwiseXORExpression ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpression )*
            {
            dbg.location(816,4);
            pushFollow(FOLLOW_bitwiseXORExpression_in_bitwiseORExpression4379);
            bitwiseXORExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(816,25);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:816:25: ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpression )*
            try { dbg.enterSubRule(84);

            loop84:
            do {
                int alt84=2;
                try { dbg.enterDecision(84);

                try {
                    isCyclicDecision = true;
                    alt84 = dfa84.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(84);}

                switch (alt84) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:816:26: ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpression
            	    {
            	    dbg.location(816,26);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:816:26: ( LineTerminator )*
            	    try { dbg.enterSubRule(82);

            	    loop82:
            	    do {
            	        int alt82=2;
            	        try { dbg.enterDecision(82);

            	        int LA82_0 = input.LA(1);

            	        if ( (LA82_0==LineTerminator) ) {
            	            alt82=1;
            	        }


            	        } finally {dbg.exitDecision(82);}

            	        switch (alt82) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(816,26);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseORExpression4382); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop82;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(82);}

            	    dbg.location(816,42);
            	    match(input,76,FOLLOW_76_in_bitwiseORExpression4385); if (state.failed) return ;
            	    dbg.location(816,46);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:816:46: ( LineTerminator )*
            	    try { dbg.enterSubRule(83);

            	    loop83:
            	    do {
            	        int alt83=2;
            	        try { dbg.enterDecision(83);

            	        int LA83_0 = input.LA(1);

            	        if ( (LA83_0==LineTerminator) ) {
            	            alt83=1;
            	        }


            	        } finally {dbg.exitDecision(83);}

            	        switch (alt83) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(816,46);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseORExpression4387); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop83;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(83);}

            	    dbg.location(816,62);
            	    pushFollow(FOLLOW_bitwiseXORExpression_in_bitwiseORExpression4390);
            	    bitwiseXORExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop84;
                }
            } while (true);
            } finally {dbg.exitSubRule(84);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 30, bitwiseORExpression_StartIndex); }
        }
        dbg.location(817, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "bitwiseORExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "bitwiseORExpression"


    // $ANTLR start "bitwiseORExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:819:1: bitwiseORExpressionNoIn : bitwiseXORExpressionNoIn ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpressionNoIn )* ;
    public final void bitwiseORExpressionNoIn() throws RecognitionException {
        int bitwiseORExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "bitwiseORExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(819, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 31) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:820:2: ( bitwiseXORExpressionNoIn ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpressionNoIn )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:820:4: bitwiseXORExpressionNoIn ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpressionNoIn )*
            {
            dbg.location(820,4);
            pushFollow(FOLLOW_bitwiseXORExpressionNoIn_in_bitwiseORExpressionNoIn4404);
            bitwiseXORExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(820,29);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:820:29: ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpressionNoIn )*
            try { dbg.enterSubRule(87);

            loop87:
            do {
                int alt87=2;
                try { dbg.enterDecision(87);

                try {
                    isCyclicDecision = true;
                    alt87 = dfa87.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(87);}

                switch (alt87) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:820:30: ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpressionNoIn
            	    {
            	    dbg.location(820,30);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:820:30: ( LineTerminator )*
            	    try { dbg.enterSubRule(85);

            	    loop85:
            	    do {
            	        int alt85=2;
            	        try { dbg.enterDecision(85);

            	        int LA85_0 = input.LA(1);

            	        if ( (LA85_0==LineTerminator) ) {
            	            alt85=1;
            	        }


            	        } finally {dbg.exitDecision(85);}

            	        switch (alt85) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(820,30);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseORExpressionNoIn4407); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop85;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(85);}

            	    dbg.location(820,46);
            	    match(input,76,FOLLOW_76_in_bitwiseORExpressionNoIn4410); if (state.failed) return ;
            	    dbg.location(820,50);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:820:50: ( LineTerminator )*
            	    try { dbg.enterSubRule(86);

            	    loop86:
            	    do {
            	        int alt86=2;
            	        try { dbg.enterDecision(86);

            	        int LA86_0 = input.LA(1);

            	        if ( (LA86_0==LineTerminator) ) {
            	            alt86=1;
            	        }


            	        } finally {dbg.exitDecision(86);}

            	        switch (alt86) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(820,50);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_bitwiseORExpressionNoIn4412); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop86;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(86);}

            	    dbg.location(820,66);
            	    pushFollow(FOLLOW_bitwiseXORExpressionNoIn_in_bitwiseORExpressionNoIn4415);
            	    bitwiseXORExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop87;
                }
            } while (true);
            } finally {dbg.exitSubRule(87);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 31, bitwiseORExpressionNoIn_StartIndex); }
        }
        dbg.location(821, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "bitwiseORExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "bitwiseORExpressionNoIn"


    // $ANTLR start "logicalANDExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:823:1: logicalANDExpression : bitwiseORExpression ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpression )* ;
    public final void logicalANDExpression() throws RecognitionException {
        int logicalANDExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "logicalANDExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(823, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 32) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:824:2: ( bitwiseORExpression ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:824:4: bitwiseORExpression ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpression )*
            {
            dbg.location(824,4);
            pushFollow(FOLLOW_bitwiseORExpression_in_logicalANDExpression4429);
            bitwiseORExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(824,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:824:24: ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpression )*
            try { dbg.enterSubRule(90);

            loop90:
            do {
                int alt90=2;
                try { dbg.enterDecision(90);

                try {
                    isCyclicDecision = true;
                    alt90 = dfa90.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(90);}

                switch (alt90) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:824:25: ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpression
            	    {
            	    dbg.location(824,25);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:824:25: ( LineTerminator )*
            	    try { dbg.enterSubRule(88);

            	    loop88:
            	    do {
            	        int alt88=2;
            	        try { dbg.enterDecision(88);

            	        int LA88_0 = input.LA(1);

            	        if ( (LA88_0==LineTerminator) ) {
            	            alt88=1;
            	        }


            	        } finally {dbg.exitDecision(88);}

            	        switch (alt88) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(824,25);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_logicalANDExpression4432); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop88;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(88);}

            	    dbg.location(824,41);
            	    match(input,77,FOLLOW_77_in_logicalANDExpression4435); if (state.failed) return ;
            	    dbg.location(824,46);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:824:46: ( LineTerminator )*
            	    try { dbg.enterSubRule(89);

            	    loop89:
            	    do {
            	        int alt89=2;
            	        try { dbg.enterDecision(89);

            	        int LA89_0 = input.LA(1);

            	        if ( (LA89_0==LineTerminator) ) {
            	            alt89=1;
            	        }


            	        } finally {dbg.exitDecision(89);}

            	        switch (alt89) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(824,46);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_logicalANDExpression4437); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop89;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(89);}

            	    dbg.location(824,62);
            	    pushFollow(FOLLOW_bitwiseORExpression_in_logicalANDExpression4440);
            	    bitwiseORExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop90;
                }
            } while (true);
            } finally {dbg.exitSubRule(90);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 32, logicalANDExpression_StartIndex); }
        }
        dbg.location(825, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "logicalANDExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "logicalANDExpression"


    // $ANTLR start "logicalANDExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:827:1: logicalANDExpressionNoIn : bitwiseORExpressionNoIn ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpressionNoIn )* ;
    public final void logicalANDExpressionNoIn() throws RecognitionException {
        int logicalANDExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "logicalANDExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(827, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 33) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:828:2: ( bitwiseORExpressionNoIn ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpressionNoIn )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:828:4: bitwiseORExpressionNoIn ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpressionNoIn )*
            {
            dbg.location(828,4);
            pushFollow(FOLLOW_bitwiseORExpressionNoIn_in_logicalANDExpressionNoIn4454);
            bitwiseORExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(828,28);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:828:28: ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpressionNoIn )*
            try { dbg.enterSubRule(93);

            loop93:
            do {
                int alt93=2;
                try { dbg.enterDecision(93);

                try {
                    isCyclicDecision = true;
                    alt93 = dfa93.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(93);}

                switch (alt93) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:828:29: ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpressionNoIn
            	    {
            	    dbg.location(828,29);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:828:29: ( LineTerminator )*
            	    try { dbg.enterSubRule(91);

            	    loop91:
            	    do {
            	        int alt91=2;
            	        try { dbg.enterDecision(91);

            	        int LA91_0 = input.LA(1);

            	        if ( (LA91_0==LineTerminator) ) {
            	            alt91=1;
            	        }


            	        } finally {dbg.exitDecision(91);}

            	        switch (alt91) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(828,29);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_logicalANDExpressionNoIn4457); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop91;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(91);}

            	    dbg.location(828,45);
            	    match(input,77,FOLLOW_77_in_logicalANDExpressionNoIn4460); if (state.failed) return ;
            	    dbg.location(828,50);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:828:50: ( LineTerminator )*
            	    try { dbg.enterSubRule(92);

            	    loop92:
            	    do {
            	        int alt92=2;
            	        try { dbg.enterDecision(92);

            	        int LA92_0 = input.LA(1);

            	        if ( (LA92_0==LineTerminator) ) {
            	            alt92=1;
            	        }


            	        } finally {dbg.exitDecision(92);}

            	        switch (alt92) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(828,50);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_logicalANDExpressionNoIn4462); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop92;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(92);}

            	    dbg.location(828,66);
            	    pushFollow(FOLLOW_bitwiseORExpressionNoIn_in_logicalANDExpressionNoIn4465);
            	    bitwiseORExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop93;
                }
            } while (true);
            } finally {dbg.exitSubRule(93);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 33, logicalANDExpressionNoIn_StartIndex); }
        }
        dbg.location(829, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "logicalANDExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "logicalANDExpressionNoIn"


    // $ANTLR start "logicalORExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:831:1: logicalORExpression : logicalANDExpression ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpression )* ;
    public final void logicalORExpression() throws RecognitionException {
        int logicalORExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "logicalORExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(831, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 34) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:832:2: ( logicalANDExpression ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:832:4: logicalANDExpression ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpression )*
            {
            dbg.location(832,4);
            pushFollow(FOLLOW_logicalANDExpression_in_logicalORExpression4479);
            logicalANDExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(832,25);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:832:25: ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpression )*
            try { dbg.enterSubRule(96);

            loop96:
            do {
                int alt96=2;
                try { dbg.enterDecision(96);

                try {
                    isCyclicDecision = true;
                    alt96 = dfa96.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(96);}

                switch (alt96) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:832:26: ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpression
            	    {
            	    dbg.location(832,26);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:832:26: ( LineTerminator )*
            	    try { dbg.enterSubRule(94);

            	    loop94:
            	    do {
            	        int alt94=2;
            	        try { dbg.enterDecision(94);

            	        int LA94_0 = input.LA(1);

            	        if ( (LA94_0==LineTerminator) ) {
            	            alt94=1;
            	        }


            	        } finally {dbg.exitDecision(94);}

            	        switch (alt94) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(832,26);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_logicalORExpression4482); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop94;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(94);}

            	    dbg.location(832,42);
            	    match(input,78,FOLLOW_78_in_logicalORExpression4485); if (state.failed) return ;
            	    dbg.location(832,47);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:832:47: ( LineTerminator )*
            	    try { dbg.enterSubRule(95);

            	    loop95:
            	    do {
            	        int alt95=2;
            	        try { dbg.enterDecision(95);

            	        int LA95_0 = input.LA(1);

            	        if ( (LA95_0==LineTerminator) ) {
            	            alt95=1;
            	        }


            	        } finally {dbg.exitDecision(95);}

            	        switch (alt95) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(832,47);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_logicalORExpression4487); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop95;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(95);}

            	    dbg.location(832,63);
            	    pushFollow(FOLLOW_logicalANDExpression_in_logicalORExpression4490);
            	    logicalANDExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop96;
                }
            } while (true);
            } finally {dbg.exitSubRule(96);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 34, logicalORExpression_StartIndex); }
        }
        dbg.location(833, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "logicalORExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "logicalORExpression"


    // $ANTLR start "logicalORExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:835:1: logicalORExpressionNoIn : logicalANDExpressionNoIn ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpressionNoIn )* ;
    public final void logicalORExpressionNoIn() throws RecognitionException {
        int logicalORExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "logicalORExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(835, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 35) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:836:2: ( logicalANDExpressionNoIn ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpressionNoIn )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:836:4: logicalANDExpressionNoIn ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpressionNoIn )*
            {
            dbg.location(836,4);
            pushFollow(FOLLOW_logicalANDExpressionNoIn_in_logicalORExpressionNoIn4503);
            logicalANDExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(836,29);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:836:29: ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpressionNoIn )*
            try { dbg.enterSubRule(99);

            loop99:
            do {
                int alt99=2;
                try { dbg.enterDecision(99);

                try {
                    isCyclicDecision = true;
                    alt99 = dfa99.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(99);}

                switch (alt99) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:836:30: ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpressionNoIn
            	    {
            	    dbg.location(836,30);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:836:30: ( LineTerminator )*
            	    try { dbg.enterSubRule(97);

            	    loop97:
            	    do {
            	        int alt97=2;
            	        try { dbg.enterDecision(97);

            	        int LA97_0 = input.LA(1);

            	        if ( (LA97_0==LineTerminator) ) {
            	            alt97=1;
            	        }


            	        } finally {dbg.exitDecision(97);}

            	        switch (alt97) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(836,30);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_logicalORExpressionNoIn4506); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop97;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(97);}

            	    dbg.location(836,46);
            	    match(input,78,FOLLOW_78_in_logicalORExpressionNoIn4509); if (state.failed) return ;
            	    dbg.location(836,51);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:836:51: ( LineTerminator )*
            	    try { dbg.enterSubRule(98);

            	    loop98:
            	    do {
            	        int alt98=2;
            	        try { dbg.enterDecision(98);

            	        int LA98_0 = input.LA(1);

            	        if ( (LA98_0==LineTerminator) ) {
            	            alt98=1;
            	        }


            	        } finally {dbg.exitDecision(98);}

            	        switch (alt98) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(836,51);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_logicalORExpressionNoIn4511); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop98;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(98);}

            	    dbg.location(836,67);
            	    pushFollow(FOLLOW_logicalANDExpressionNoIn_in_logicalORExpressionNoIn4514);
            	    logicalANDExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop99;
                }
            } while (true);
            } finally {dbg.exitSubRule(99);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 35, logicalORExpressionNoIn_StartIndex); }
        }
        dbg.location(837, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "logicalORExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "logicalORExpressionNoIn"


    // $ANTLR start "conditionalExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:839:1: conditionalExpression : logicalORExpression ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )? ;
    public final void conditionalExpression() throws RecognitionException {
        int conditionalExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "conditionalExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(839, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 36) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:840:2: ( logicalORExpression ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )? )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:840:4: logicalORExpression ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )?
            {
            dbg.location(840,4);
            pushFollow(FOLLOW_logicalORExpression_in_conditionalExpression4528);
            logicalORExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(840,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:840:24: ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )?
            int alt104=2;
            try { dbg.enterSubRule(104);
            try { dbg.enterDecision(104);

            try {
                isCyclicDecision = true;
                alt104 = dfa104.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(104);}

            switch (alt104) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:840:25: ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression
                    {
                    dbg.location(840,25);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:840:25: ( LineTerminator )*
                    try { dbg.enterSubRule(100);

                    loop100:
                    do {
                        int alt100=2;
                        try { dbg.enterDecision(100);

                        int LA100_0 = input.LA(1);

                        if ( (LA100_0==LineTerminator) ) {
                            alt100=1;
                        }


                        } finally {dbg.exitDecision(100);}

                        switch (alt100) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(840,25);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_conditionalExpression4531); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop100;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(100);}

                    dbg.location(840,41);
                    match(input,79,FOLLOW_79_in_conditionalExpression4534); if (state.failed) return ;
                    dbg.location(840,45);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:840:45: ( LineTerminator )*
                    try { dbg.enterSubRule(101);

                    loop101:
                    do {
                        int alt101=2;
                        try { dbg.enterDecision(101);

                        int LA101_0 = input.LA(1);

                        if ( (LA101_0==LineTerminator) ) {
                            alt101=1;
                        }


                        } finally {dbg.exitDecision(101);}

                        switch (alt101) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(840,45);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_conditionalExpression4536); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop101;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(101);}

                    dbg.location(840,61);
                    pushFollow(FOLLOW_assignmentExpression_in_conditionalExpression4539);
                    assignmentExpression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(840,82);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:840:82: ( LineTerminator )*
                    try { dbg.enterSubRule(102);

                    loop102:
                    do {
                        int alt102=2;
                        try { dbg.enterDecision(102);

                        int LA102_0 = input.LA(1);

                        if ( (LA102_0==LineTerminator) ) {
                            alt102=1;
                        }


                        } finally {dbg.exitDecision(102);}

                        switch (alt102) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(840,82);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_conditionalExpression4541); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop102;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(102);}

                    dbg.location(840,98);
                    match(input,43,FOLLOW_43_in_conditionalExpression4544); if (state.failed) return ;
                    dbg.location(840,102);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:840:102: ( LineTerminator )*
                    try { dbg.enterSubRule(103);

                    loop103:
                    do {
                        int alt103=2;
                        try { dbg.enterDecision(103);

                        int LA103_0 = input.LA(1);

                        if ( (LA103_0==LineTerminator) ) {
                            alt103=1;
                        }


                        } finally {dbg.exitDecision(103);}

                        switch (alt103) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(840,102);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_conditionalExpression4546); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop103;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(103);}

                    dbg.location(840,118);
                    pushFollow(FOLLOW_assignmentExpression_in_conditionalExpression4549);
                    assignmentExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(104);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 36, conditionalExpression_StartIndex); }
        }
        dbg.location(841, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "conditionalExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "conditionalExpression"


    // $ANTLR start "conditionalExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:843:1: conditionalExpressionNoIn : logicalORExpressionNoIn ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )? ;
    public final void conditionalExpressionNoIn() throws RecognitionException {
        int conditionalExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "conditionalExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(843, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 37) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:844:2: ( logicalORExpressionNoIn ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )? )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:844:4: logicalORExpressionNoIn ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )?
            {
            dbg.location(844,4);
            pushFollow(FOLLOW_logicalORExpressionNoIn_in_conditionalExpressionNoIn4563);
            logicalORExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(844,28);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:844:28: ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )?
            int alt109=2;
            try { dbg.enterSubRule(109);
            try { dbg.enterDecision(109);

            try {
                isCyclicDecision = true;
                alt109 = dfa109.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(109);}

            switch (alt109) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:844:29: ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression
                    {
                    dbg.location(844,29);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:844:29: ( LineTerminator )*
                    try { dbg.enterSubRule(105);

                    loop105:
                    do {
                        int alt105=2;
                        try { dbg.enterDecision(105);

                        int LA105_0 = input.LA(1);

                        if ( (LA105_0==LineTerminator) ) {
                            alt105=1;
                        }


                        } finally {dbg.exitDecision(105);}

                        switch (alt105) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(844,29);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_conditionalExpressionNoIn4566); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop105;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(105);}

                    dbg.location(844,45);
                    match(input,79,FOLLOW_79_in_conditionalExpressionNoIn4569); if (state.failed) return ;
                    dbg.location(844,49);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:844:49: ( LineTerminator )*
                    try { dbg.enterSubRule(106);

                    loop106:
                    do {
                        int alt106=2;
                        try { dbg.enterDecision(106);

                        int LA106_0 = input.LA(1);

                        if ( (LA106_0==LineTerminator) ) {
                            alt106=1;
                        }


                        } finally {dbg.exitDecision(106);}

                        switch (alt106) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(844,49);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_conditionalExpressionNoIn4571); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop106;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(106);}

                    dbg.location(844,65);
                    pushFollow(FOLLOW_assignmentExpression_in_conditionalExpressionNoIn4574);
                    assignmentExpression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(844,86);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:844:86: ( LineTerminator )*
                    try { dbg.enterSubRule(107);

                    loop107:
                    do {
                        int alt107=2;
                        try { dbg.enterDecision(107);

                        int LA107_0 = input.LA(1);

                        if ( (LA107_0==LineTerminator) ) {
                            alt107=1;
                        }


                        } finally {dbg.exitDecision(107);}

                        switch (alt107) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(844,86);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_conditionalExpressionNoIn4576); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop107;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(107);}

                    dbg.location(844,102);
                    match(input,43,FOLLOW_43_in_conditionalExpressionNoIn4579); if (state.failed) return ;
                    dbg.location(844,106);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:844:106: ( LineTerminator )*
                    try { dbg.enterSubRule(108);

                    loop108:
                    do {
                        int alt108=2;
                        try { dbg.enterDecision(108);

                        int LA108_0 = input.LA(1);

                        if ( (LA108_0==LineTerminator) ) {
                            alt108=1;
                        }


                        } finally {dbg.exitDecision(108);}

                        switch (alt108) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(844,106);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_conditionalExpressionNoIn4581); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop108;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(108);}

                    dbg.location(844,122);
                    pushFollow(FOLLOW_assignmentExpression_in_conditionalExpressionNoIn4584);
                    assignmentExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(109);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 37, conditionalExpressionNoIn_StartIndex); }
        }
        dbg.location(845, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "conditionalExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "conditionalExpressionNoIn"


    // $ANTLR start "assignmentExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:847:1: assignmentExpression : ( conditionalExpression | leftHandSideExpression ( LineTerminator )* assignmentOperator ( LineTerminator )* assignmentExpression );
    public final void assignmentExpression() throws RecognitionException {
        int assignmentExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "assignmentExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(847, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 38) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:848:2: ( conditionalExpression | leftHandSideExpression ( LineTerminator )* assignmentOperator ( LineTerminator )* assignmentExpression )
            int alt112=2;
            try { dbg.enterDecision(112);

            try {
                isCyclicDecision = true;
                alt112 = dfa112.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(112);}

            switch (alt112) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:848:4: conditionalExpression
                    {
                    dbg.location(848,4);
                    pushFollow(FOLLOW_conditionalExpression_in_assignmentExpression4597);
                    conditionalExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:849:4: leftHandSideExpression ( LineTerminator )* assignmentOperator ( LineTerminator )* assignmentExpression
                    {
                    dbg.location(849,4);
                    pushFollow(FOLLOW_leftHandSideExpression_in_assignmentExpression4602);
                    leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(849,27);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:849:27: ( LineTerminator )*
                    try { dbg.enterSubRule(110);

                    loop110:
                    do {
                        int alt110=2;
                        try { dbg.enterDecision(110);

                        int LA110_0 = input.LA(1);

                        if ( (LA110_0==LineTerminator) ) {
                            alt110=1;
                        }


                        } finally {dbg.exitDecision(110);}

                        switch (alt110) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(849,27);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_assignmentExpression4604); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop110;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(110);}

                    dbg.location(849,43);
                    pushFollow(FOLLOW_assignmentOperator_in_assignmentExpression4607);
                    assignmentOperator();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(849,62);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:849:62: ( LineTerminator )*
                    try { dbg.enterSubRule(111);

                    loop111:
                    do {
                        int alt111=2;
                        try { dbg.enterDecision(111);

                        int LA111_0 = input.LA(1);

                        if ( (LA111_0==LineTerminator) ) {
                            alt111=1;
                        }


                        } finally {dbg.exitDecision(111);}

                        switch (alt111) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(849,62);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_assignmentExpression4609); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop111;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(111);}

                    dbg.location(849,78);
                    pushFollow(FOLLOW_assignmentExpression_in_assignmentExpression4612);
                    assignmentExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 38, assignmentExpression_StartIndex); }
        }
        dbg.location(850, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "assignmentExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "assignmentExpression"


    // $ANTLR start "assignmentExpressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:852:1: assignmentExpressionNoIn : ( conditionalExpressionNoIn | leftHandSideExpression ( LineTerminator )* assignmentOperator ( LineTerminator )* assignmentExpressionNoIn );
    public final void assignmentExpressionNoIn() throws RecognitionException {
        int assignmentExpressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "assignmentExpressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(852, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 39) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:853:2: ( conditionalExpressionNoIn | leftHandSideExpression ( LineTerminator )* assignmentOperator ( LineTerminator )* assignmentExpressionNoIn )
            int alt115=2;
            try { dbg.enterDecision(115);

            try {
                isCyclicDecision = true;
                alt115 = dfa115.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(115);}

            switch (alt115) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:853:4: conditionalExpressionNoIn
                    {
                    dbg.location(853,4);
                    pushFollow(FOLLOW_conditionalExpressionNoIn_in_assignmentExpressionNoIn4624);
                    conditionalExpressionNoIn();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:854:4: leftHandSideExpression ( LineTerminator )* assignmentOperator ( LineTerminator )* assignmentExpressionNoIn
                    {
                    dbg.location(854,4);
                    pushFollow(FOLLOW_leftHandSideExpression_in_assignmentExpressionNoIn4629);
                    leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(854,27);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:854:27: ( LineTerminator )*
                    try { dbg.enterSubRule(113);

                    loop113:
                    do {
                        int alt113=2;
                        try { dbg.enterDecision(113);

                        int LA113_0 = input.LA(1);

                        if ( (LA113_0==LineTerminator) ) {
                            alt113=1;
                        }


                        } finally {dbg.exitDecision(113);}

                        switch (alt113) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(854,27);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_assignmentExpressionNoIn4631); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop113;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(113);}

                    dbg.location(854,43);
                    pushFollow(FOLLOW_assignmentOperator_in_assignmentExpressionNoIn4634);
                    assignmentOperator();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(854,62);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:854:62: ( LineTerminator )*
                    try { dbg.enterSubRule(114);

                    loop114:
                    do {
                        int alt114=2;
                        try { dbg.enterDecision(114);

                        int LA114_0 = input.LA(1);

                        if ( (LA114_0==LineTerminator) ) {
                            alt114=1;
                        }


                        } finally {dbg.exitDecision(114);}

                        switch (alt114) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(854,62);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_assignmentExpressionNoIn4636); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop114;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(114);}

                    dbg.location(854,78);
                    pushFollow(FOLLOW_assignmentExpressionNoIn_in_assignmentExpressionNoIn4639);
                    assignmentExpressionNoIn();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 39, assignmentExpressionNoIn_StartIndex); }
        }
        dbg.location(855, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "assignmentExpressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "assignmentExpressionNoIn"


    // $ANTLR start "assignmentOperator"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:857:1: assignmentOperator : ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|=' ) ;
    public final void assignmentOperator() throws RecognitionException {
        int assignmentOperator_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "assignmentOperator");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(857, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 40) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:858:2: ( ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|=' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:858:4: ( '=' | '*=' | '/=' | '%=' | '+=' | '-=' | '<<=' | '>>=' | '>>>=' | '&=' | '^=' | '|=' )
            {
            dbg.location(858,4);
            if ( (input.LA(1)>=80 && input.LA(1)<=91) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 40, assignmentOperator_StartIndex); }
        }
        dbg.location(859, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "assignmentOperator");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "assignmentOperator"


    // $ANTLR start "expression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:861:1: expression : assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )* ;
    public final void expression() throws RecognitionException {
        int expression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "expression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(861, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 41) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:862:2: ( assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:862:4: assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )*
            {
            dbg.location(862,4);
            pushFollow(FOLLOW_assignmentExpression_in_expression4709);
            assignmentExpression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(862,25);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:862:25: ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )*
            try { dbg.enterSubRule(118);

            loop118:
            do {
                int alt118=2;
                try { dbg.enterDecision(118);

                try {
                    isCyclicDecision = true;
                    alt118 = dfa118.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(118);}

                switch (alt118) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:862:26: ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression
            	    {
            	    dbg.location(862,26);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:862:26: ( LineTerminator )*
            	    try { dbg.enterSubRule(116);

            	    loop116:
            	    do {
            	        int alt116=2;
            	        try { dbg.enterDecision(116);

            	        int LA116_0 = input.LA(1);

            	        if ( (LA116_0==LineTerminator) ) {
            	            alt116=1;
            	        }


            	        } finally {dbg.exitDecision(116);}

            	        switch (alt116) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(862,26);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_expression4712); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop116;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(116);}

            	    dbg.location(862,42);
            	    match(input,39,FOLLOW_39_in_expression4715); if (state.failed) return ;
            	    dbg.location(862,46);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:862:46: ( LineTerminator )*
            	    try { dbg.enterSubRule(117);

            	    loop117:
            	    do {
            	        int alt117=2;
            	        try { dbg.enterDecision(117);

            	        int LA117_0 = input.LA(1);

            	        if ( (LA117_0==LineTerminator) ) {
            	            alt117=1;
            	        }


            	        } finally {dbg.exitDecision(117);}

            	        switch (alt117) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(862,46);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_expression4717); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop117;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(117);}

            	    dbg.location(862,62);
            	    pushFollow(FOLLOW_assignmentExpression_in_expression4720);
            	    assignmentExpression();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop118;
                }
            } while (true);
            } finally {dbg.exitSubRule(118);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 41, expression_StartIndex); }
        }
        dbg.location(863, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "expression"


    // $ANTLR start "expressionNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:865:1: expressionNoIn : assignmentExpressionNoIn ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpressionNoIn )* ;
    public final void expressionNoIn() throws RecognitionException {
        int expressionNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "expressionNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(865, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 42) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:866:2: ( assignmentExpressionNoIn ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpressionNoIn )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:866:4: assignmentExpressionNoIn ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpressionNoIn )*
            {
            dbg.location(866,4);
            pushFollow(FOLLOW_assignmentExpressionNoIn_in_expressionNoIn4734);
            assignmentExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(866,29);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:866:29: ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpressionNoIn )*
            try { dbg.enterSubRule(121);

            loop121:
            do {
                int alt121=2;
                try { dbg.enterDecision(121);

                try {
                    isCyclicDecision = true;
                    alt121 = dfa121.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(121);}

                switch (alt121) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:866:30: ( LineTerminator )* ',' ( LineTerminator )* assignmentExpressionNoIn
            	    {
            	    dbg.location(866,30);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:866:30: ( LineTerminator )*
            	    try { dbg.enterSubRule(119);

            	    loop119:
            	    do {
            	        int alt119=2;
            	        try { dbg.enterDecision(119);

            	        int LA119_0 = input.LA(1);

            	        if ( (LA119_0==LineTerminator) ) {
            	            alt119=1;
            	        }


            	        } finally {dbg.exitDecision(119);}

            	        switch (alt119) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(866,30);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_expressionNoIn4737); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop119;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(119);}

            	    dbg.location(866,46);
            	    match(input,39,FOLLOW_39_in_expressionNoIn4740); if (state.failed) return ;
            	    dbg.location(866,50);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:866:50: ( LineTerminator )*
            	    try { dbg.enterSubRule(120);

            	    loop120:
            	    do {
            	        int alt120=2;
            	        try { dbg.enterDecision(120);

            	        int LA120_0 = input.LA(1);

            	        if ( (LA120_0==LineTerminator) ) {
            	            alt120=1;
            	        }


            	        } finally {dbg.exitDecision(120);}

            	        switch (alt120) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(866,50);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_expressionNoIn4742); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop120;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(120);}

            	    dbg.location(866,66);
            	    pushFollow(FOLLOW_assignmentExpressionNoIn_in_expressionNoIn4745);
            	    assignmentExpressionNoIn();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop121;
                }
            } while (true);
            } finally {dbg.exitSubRule(121);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 42, expressionNoIn_StartIndex); }
        }
        dbg.location(867, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expressionNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "expressionNoIn"


    // $ANTLR start "statement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:873:1: statement : ( blockStatement | variableStatement | emptyStatement | expressionStatement | ifStatement | iterationStatement | continueStatement | breakStatement | returnStatement | withStatement | labelledStatement | switchStatement | throwStatement | tryStatement | useNamespaceStatement | includeStatement | importStatement | metaDataStatement );
    public final void statement() throws RecognitionException {
        int statement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "statement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(873, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:874:2: ( blockStatement | variableStatement | emptyStatement | expressionStatement | ifStatement | iterationStatement | continueStatement | breakStatement | returnStatement | withStatement | labelledStatement | switchStatement | throwStatement | tryStatement | useNamespaceStatement | includeStatement | importStatement | metaDataStatement )
            int alt122=18;
            try { dbg.enterDecision(122);

            try {
                isCyclicDecision = true;
                alt122 = dfa122.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(122);}

            switch (alt122) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:874:4: blockStatement
                    {
                    dbg.location(874,4);
                    pushFollow(FOLLOW_blockStatement_in_statement4763);
                    blockStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:875:4: variableStatement
                    {
                    dbg.location(875,4);
                    pushFollow(FOLLOW_variableStatement_in_statement4768);
                    variableStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:876:4: emptyStatement
                    {
                    dbg.location(876,4);
                    pushFollow(FOLLOW_emptyStatement_in_statement4773);
                    emptyStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:877:4: expressionStatement
                    {
                    dbg.location(877,4);
                    pushFollow(FOLLOW_expressionStatement_in_statement4778);
                    expressionStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:878:4: ifStatement
                    {
                    dbg.location(878,4);
                    pushFollow(FOLLOW_ifStatement_in_statement4783);
                    ifStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 6 :
                    dbg.enterAlt(6);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:879:4: iterationStatement
                    {
                    dbg.location(879,4);
                    pushFollow(FOLLOW_iterationStatement_in_statement4788);
                    iterationStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 7 :
                    dbg.enterAlt(7);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:880:4: continueStatement
                    {
                    dbg.location(880,4);
                    pushFollow(FOLLOW_continueStatement_in_statement4793);
                    continueStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 8 :
                    dbg.enterAlt(8);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:881:4: breakStatement
                    {
                    dbg.location(881,4);
                    pushFollow(FOLLOW_breakStatement_in_statement4798);
                    breakStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 9 :
                    dbg.enterAlt(9);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:882:4: returnStatement
                    {
                    dbg.location(882,4);
                    pushFollow(FOLLOW_returnStatement_in_statement4803);
                    returnStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 10 :
                    dbg.enterAlt(10);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:883:4: withStatement
                    {
                    dbg.location(883,4);
                    pushFollow(FOLLOW_withStatement_in_statement4808);
                    withStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 11 :
                    dbg.enterAlt(11);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:884:4: labelledStatement
                    {
                    dbg.location(884,4);
                    pushFollow(FOLLOW_labelledStatement_in_statement4813);
                    labelledStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 12 :
                    dbg.enterAlt(12);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:885:4: switchStatement
                    {
                    dbg.location(885,4);
                    pushFollow(FOLLOW_switchStatement_in_statement4818);
                    switchStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 13 :
                    dbg.enterAlt(13);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:886:4: throwStatement
                    {
                    dbg.location(886,4);
                    pushFollow(FOLLOW_throwStatement_in_statement4823);
                    throwStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 14 :
                    dbg.enterAlt(14);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:887:4: tryStatement
                    {
                    dbg.location(887,4);
                    pushFollow(FOLLOW_tryStatement_in_statement4828);
                    tryStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 15 :
                    dbg.enterAlt(15);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:888:4: useNamespaceStatement
                    {
                    dbg.location(888,4);
                    pushFollow(FOLLOW_useNamespaceStatement_in_statement4833);
                    useNamespaceStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 16 :
                    dbg.enterAlt(16);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:889:4: includeStatement
                    {
                    dbg.location(889,4);
                    pushFollow(FOLLOW_includeStatement_in_statement4838);
                    includeStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 17 :
                    dbg.enterAlt(17);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:890:4: importStatement
                    {
                    dbg.location(890,4);
                    pushFollow(FOLLOW_importStatement_in_statement4843);
                    importStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 18 :
                    dbg.enterAlt(18);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:891:4: metaDataStatement
                    {
                    dbg.location(891,4);
                    pushFollow(FOLLOW_metaDataStatement_in_statement4848);
                    metaDataStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 43, statement_StartIndex); }
        }
        dbg.location(892, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "statement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "statement"


    // $ANTLR start "blockStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:894:1: blockStatement : '{' ( LineTerminator )* ( statementList )? ( LineTerminator )* '}' ;
    public final void blockStatement() throws RecognitionException {
        int blockStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "blockStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(894, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 44) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:2: ( '{' ( LineTerminator )* ( statementList )? ( LineTerminator )* '}' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:4: '{' ( LineTerminator )* ( statementList )? ( LineTerminator )* '}'
            {
            dbg.location(895,4);
            match(input,41,FOLLOW_41_in_blockStatement4859); if (state.failed) return ;
            dbg.location(895,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:8: ( LineTerminator )*
            try { dbg.enterSubRule(123);

            loop123:
            do {
                int alt123=2;
                try { dbg.enterDecision(123);

                int LA123_0 = input.LA(1);

                if ( (LA123_0==LineTerminator) ) {
                    int LA123_1 = input.LA(2);

                    if ( (synpred196_AS3()) ) {
                        alt123=1;
                    }


                }


                } finally {dbg.exitDecision(123);}

                switch (alt123) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(895,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_blockStatement4861); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop123;
                }
            } while (true);
            } finally {dbg.exitSubRule(123);}

            dbg.location(895,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:24: ( statementList )?
            int alt124=2;
            try { dbg.enterSubRule(124);
            try { dbg.enterDecision(124);

            switch ( input.LA(1) ) {
                case LineTerminator:
                    {
                    int LA124_1 = input.LA(2);

                    if ( (synpred197_AS3()) ) {
                        alt124=1;
                    }
                    }
                    break;
                case Identifier:
                case NullLiteral:
                case BooleanLiteral:
                case NumericLiteral:
                case StringLiteral:
                case 34:
                case 35:
                case 36:
                case 38:
                case 41:
                case 44:
                case 47:
                case 48:
                case 49:
                case 50:
                case 51:
                case 52:
                case 53:
                case 54:
                case 55:
                case 56:
                case 92:
                case 93:
                case 94:
                case 95:
                case 97:
                case 98:
                case 99:
                case 100:
                case 101:
                case 102:
                case 103:
                case 104:
                case 107:
                case 108:
                case 111:
                case 116:
                case 127:
                case 129:
                    {
                    alt124=1;
                    }
                    break;
                case 42:
                    {
                    int LA124_3 = input.LA(2);

                    if ( (synpred197_AS3()) ) {
                        alt124=1;
                    }
                    }
                    break;
            }

            } finally {dbg.exitDecision(124);}

            switch (alt124) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: statementList
                    {
                    dbg.location(895,24);
                    pushFollow(FOLLOW_statementList_in_blockStatement4864);
                    statementList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(124);}

            dbg.location(895,39);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:39: ( LineTerminator )*
            try { dbg.enterSubRule(125);

            loop125:
            do {
                int alt125=2;
                try { dbg.enterDecision(125);

                int LA125_0 = input.LA(1);

                if ( (LA125_0==LineTerminator) ) {
                    alt125=1;
                }


                } finally {dbg.exitDecision(125);}

                switch (alt125) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(895,39);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_blockStatement4867); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop125;
                }
            } while (true);
            } finally {dbg.exitSubRule(125);}

            dbg.location(895,55);
            match(input,42,FOLLOW_42_in_blockStatement4870); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 44, blockStatement_StartIndex); }
        }
        dbg.location(896, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "blockStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "blockStatement"


    // $ANTLR start "statementList"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:898:1: statementList : ( ( LineTerminator )* statement ( LineTerminator )* )* ;
    public final void statementList() throws RecognitionException {
        int statementList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "statementList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(898, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 45) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:899:2: ( ( ( LineTerminator )* statement ( LineTerminator )* )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:899:4: ( ( LineTerminator )* statement ( LineTerminator )* )*
            {
            dbg.location(899,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:899:4: ( ( LineTerminator )* statement ( LineTerminator )* )*
            try { dbg.enterSubRule(128);

            loop128:
            do {
                int alt128=2;
                try { dbg.enterDecision(128);

                try {
                    isCyclicDecision = true;
                    alt128 = dfa128.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(128);}

                switch (alt128) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:899:5: ( LineTerminator )* statement ( LineTerminator )*
            	    {
            	    dbg.location(899,5);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:899:5: ( LineTerminator )*
            	    try { dbg.enterSubRule(126);

            	    loop126:
            	    do {
            	        int alt126=2;
            	        try { dbg.enterDecision(126);

            	        int LA126_0 = input.LA(1);

            	        if ( (LA126_0==LineTerminator) ) {
            	            alt126=1;
            	        }


            	        } finally {dbg.exitDecision(126);}

            	        switch (alt126) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(899,5);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_statementList4883); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop126;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(126);}

            	    dbg.location(899,21);
            	    pushFollow(FOLLOW_statement_in_statementList4886);
            	    statement();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(899,31);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:899:31: ( LineTerminator )*
            	    try { dbg.enterSubRule(127);

            	    loop127:
            	    do {
            	        int alt127=2;
            	        try { dbg.enterDecision(127);

            	        int LA127_0 = input.LA(1);

            	        if ( (LA127_0==LineTerminator) ) {
            	            int LA127_1 = input.LA(2);

            	            if ( (synpred200_AS3()) ) {
            	                alt127=1;
            	            }


            	        }


            	        } finally {dbg.exitDecision(127);}

            	        switch (alt127) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(899,31);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_statementList4888); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop127;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(127);}


            	    }
            	    break;

            	default :
            	    break loop128;
                }
            } while (true);
            } finally {dbg.exitSubRule(128);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 45, statementList_StartIndex); }
        }
        dbg.location(900, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "statementList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "statementList"


    // $ANTLR start "variableStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:902:1: variableStatement : ( 'var' | 'const' ) ( LineTerminator )* variableDeclarationList ( ( LineTerminator )* | ';' ) ;
    public final void variableStatement() throws RecognitionException {
        int variableStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "variableStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(902, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 46) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:2: ( ( 'var' | 'const' ) ( LineTerminator )* variableDeclarationList ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:4: ( 'var' | 'const' ) ( LineTerminator )* variableDeclarationList ( ( LineTerminator )* | ';' )
            {
            dbg.location(903,4);
            if ( (input.LA(1)>=92 && input.LA(1)<=93) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }

            dbg.location(903,22);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:22: ( LineTerminator )*
            try { dbg.enterSubRule(129);

            loop129:
            do {
                int alt129=2;
                try { dbg.enterDecision(129);

                int LA129_0 = input.LA(1);

                if ( (LA129_0==LineTerminator) ) {
                    alt129=1;
                }


                } finally {dbg.exitDecision(129);}

                switch (alt129) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(903,22);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableStatement4911); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop129;
                }
            } while (true);
            } finally {dbg.exitSubRule(129);}

            dbg.location(903,38);
            pushFollow(FOLLOW_variableDeclarationList_in_variableStatement4914);
            variableDeclarationList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(903,62);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:62: ( ( LineTerminator )* | ';' )
            int alt131=2;
            try { dbg.enterSubRule(131);
            try { dbg.enterDecision(131);

            int LA131_0 = input.LA(1);

            if ( (LA131_0==EOF||LA131_0==LineTerminator||LA131_0==Identifier||(LA131_0>=NullLiteral && LA131_0<=StringLiteral)||(LA131_0>=34 && LA131_0<=36)||LA131_0==38||(LA131_0>=41 && LA131_0<=42)||LA131_0==44||(LA131_0>=47 && LA131_0<=56)||(LA131_0>=92 && LA131_0<=93)||(LA131_0>=95 && LA131_0<=108)||LA131_0==111||LA131_0==116||(LA131_0>=118 && LA131_0<=120)||(LA131_0>=125 && LA131_0<=127)||(LA131_0>=129 && LA131_0<=131)) ) {
                alt131=1;
            }
            else if ( (LA131_0==94) ) {
                int LA131_2 = input.LA(2);

                if ( (synpred205_AS3()) ) {
                    alt131=1;
                }
                else if ( (true) ) {
                    alt131=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 131, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 131, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(131);}

            switch (alt131) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:63: ( LineTerminator )*
                    {
                    dbg.location(903,63);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:63: ( LineTerminator )*
                    try { dbg.enterSubRule(130);

                    loop130:
                    do {
                        int alt130=2;
                        try { dbg.enterDecision(130);

                        int LA130_0 = input.LA(1);

                        if ( (LA130_0==LineTerminator) ) {
                            int LA130_1 = input.LA(2);

                            if ( (synpred204_AS3()) ) {
                                alt130=1;
                            }


                        }


                        } finally {dbg.exitDecision(130);}

                        switch (alt130) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(903,63);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableStatement4917); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop130;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(130);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:81: ';'
                    {
                    dbg.location(903,81);
                    match(input,94,FOLLOW_94_in_variableStatement4922); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(131);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 46, variableStatement_StartIndex); }
        }
        dbg.location(904, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "variableStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "variableStatement"


    // $ANTLR start "variableDeclarationList"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:906:1: variableDeclarationList : variableDeclaration ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclaration )* ;
    public final void variableDeclarationList() throws RecognitionException {
        int variableDeclarationList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "variableDeclarationList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(906, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 47) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:907:2: ( variableDeclaration ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclaration )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:907:4: variableDeclaration ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclaration )*
            {
            dbg.location(907,4);
            pushFollow(FOLLOW_variableDeclaration_in_variableDeclarationList4935);
            variableDeclaration();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(907,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:907:24: ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclaration )*
            try { dbg.enterSubRule(134);

            loop134:
            do {
                int alt134=2;
                try { dbg.enterDecision(134);

                try {
                    isCyclicDecision = true;
                    alt134 = dfa134.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(134);}

                switch (alt134) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:907:25: ( LineTerminator )* ',' ( LineTerminator )* variableDeclaration
            	    {
            	    dbg.location(907,25);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:907:25: ( LineTerminator )*
            	    try { dbg.enterSubRule(132);

            	    loop132:
            	    do {
            	        int alt132=2;
            	        try { dbg.enterDecision(132);

            	        int LA132_0 = input.LA(1);

            	        if ( (LA132_0==LineTerminator) ) {
            	            alt132=1;
            	        }


            	        } finally {dbg.exitDecision(132);}

            	        switch (alt132) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(907,25);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableDeclarationList4938); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop132;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(132);}

            	    dbg.location(907,41);
            	    match(input,39,FOLLOW_39_in_variableDeclarationList4941); if (state.failed) return ;
            	    dbg.location(907,45);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:907:45: ( LineTerminator )*
            	    try { dbg.enterSubRule(133);

            	    loop133:
            	    do {
            	        int alt133=2;
            	        try { dbg.enterDecision(133);

            	        int LA133_0 = input.LA(1);

            	        if ( (LA133_0==LineTerminator) ) {
            	            alt133=1;
            	        }


            	        } finally {dbg.exitDecision(133);}

            	        switch (alt133) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(907,45);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableDeclarationList4943); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop133;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(133);}

            	    dbg.location(907,61);
            	    pushFollow(FOLLOW_variableDeclaration_in_variableDeclarationList4946);
            	    variableDeclaration();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop134;
                }
            } while (true);
            } finally {dbg.exitSubRule(134);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 47, variableDeclarationList_StartIndex); }
        }
        dbg.location(908, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "variableDeclarationList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "variableDeclarationList"


    // $ANTLR start "variableDeclarationListNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:910:1: variableDeclarationListNoIn : variableDeclarationNoIn ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclarationNoIn )* ;
    public final void variableDeclarationListNoIn() throws RecognitionException {
        int variableDeclarationListNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "variableDeclarationListNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(910, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 48) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:911:2: ( variableDeclarationNoIn ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclarationNoIn )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:911:4: variableDeclarationNoIn ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclarationNoIn )*
            {
            dbg.location(911,4);
            pushFollow(FOLLOW_variableDeclarationNoIn_in_variableDeclarationListNoIn4960);
            variableDeclarationNoIn();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(911,28);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:911:28: ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclarationNoIn )*
            try { dbg.enterSubRule(137);

            loop137:
            do {
                int alt137=2;
                try { dbg.enterDecision(137);

                try {
                    isCyclicDecision = true;
                    alt137 = dfa137.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(137);}

                switch (alt137) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:911:29: ( LineTerminator )* ',' ( LineTerminator )* variableDeclarationNoIn
            	    {
            	    dbg.location(911,29);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:911:29: ( LineTerminator )*
            	    try { dbg.enterSubRule(135);

            	    loop135:
            	    do {
            	        int alt135=2;
            	        try { dbg.enterDecision(135);

            	        int LA135_0 = input.LA(1);

            	        if ( (LA135_0==LineTerminator) ) {
            	            alt135=1;
            	        }


            	        } finally {dbg.exitDecision(135);}

            	        switch (alt135) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(911,29);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableDeclarationListNoIn4963); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop135;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(135);}

            	    dbg.location(911,45);
            	    match(input,39,FOLLOW_39_in_variableDeclarationListNoIn4966); if (state.failed) return ;
            	    dbg.location(911,49);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:911:49: ( LineTerminator )*
            	    try { dbg.enterSubRule(136);

            	    loop136:
            	    do {
            	        int alt136=2;
            	        try { dbg.enterDecision(136);

            	        int LA136_0 = input.LA(1);

            	        if ( (LA136_0==LineTerminator) ) {
            	            alt136=1;
            	        }


            	        } finally {dbg.exitDecision(136);}

            	        switch (alt136) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(911,49);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableDeclarationListNoIn4968); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop136;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(136);}

            	    dbg.location(911,65);
            	    pushFollow(FOLLOW_variableDeclarationNoIn_in_variableDeclarationListNoIn4971);
            	    variableDeclarationNoIn();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop137;
                }
            } while (true);
            } finally {dbg.exitSubRule(137);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 48, variableDeclarationListNoIn_StartIndex); }
        }
        dbg.location(912, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "variableDeclarationListNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "variableDeclarationListNoIn"


    // $ANTLR start "variableDeclaration"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:914:1: variableDeclaration : Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( initialiser )? ;
    public final void variableDeclaration() throws RecognitionException {
        int variableDeclaration_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "variableDeclaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(914, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 49) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:2: ( Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( initialiser )? )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:4: Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( initialiser )?
            {
            dbg.location(915,4);
            match(input,Identifier,FOLLOW_Identifier_in_variableDeclaration4984); if (state.failed) return ;
            dbg.location(915,15);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:15: ( LineTerminator )*
            try { dbg.enterSubRule(138);

            loop138:
            do {
                int alt138=2;
                try { dbg.enterDecision(138);

                int LA138_0 = input.LA(1);

                if ( (LA138_0==LineTerminator) ) {
                    int LA138_2 = input.LA(2);

                    if ( (synpred212_AS3()) ) {
                        alt138=1;
                    }


                }


                } finally {dbg.exitDecision(138);}

                switch (alt138) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(915,15);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableDeclaration4986); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop138;
                }
            } while (true);
            } finally {dbg.exitSubRule(138);}

            dbg.location(915,31);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:31: ( typeInformation )?
            int alt139=2;
            try { dbg.enterSubRule(139);
            try { dbg.enterDecision(139);

            int LA139_0 = input.LA(1);

            if ( (LA139_0==43) ) {
                alt139=1;
            }
            } finally {dbg.exitDecision(139);}

            switch (alt139) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: typeInformation
                    {
                    dbg.location(915,31);
                    pushFollow(FOLLOW_typeInformation_in_variableDeclaration4989);
                    typeInformation();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(139);}

            dbg.location(915,48);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:48: ( LineTerminator )*
            try { dbg.enterSubRule(140);

            loop140:
            do {
                int alt140=2;
                try { dbg.enterDecision(140);

                int LA140_0 = input.LA(1);

                if ( (LA140_0==LineTerminator) ) {
                    int LA140_2 = input.LA(2);

                    if ( (synpred214_AS3()) ) {
                        alt140=1;
                    }


                }


                } finally {dbg.exitDecision(140);}

                switch (alt140) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(915,48);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableDeclaration4992); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop140;
                }
            } while (true);
            } finally {dbg.exitSubRule(140);}

            dbg.location(915,64);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:64: ( initialiser )?
            int alt141=2;
            try { dbg.enterSubRule(141);
            try { dbg.enterDecision(141);

            int LA141_0 = input.LA(1);

            if ( (LA141_0==80) ) {
                alt141=1;
            }
            } finally {dbg.exitDecision(141);}

            switch (alt141) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: initialiser
                    {
                    dbg.location(915,64);
                    pushFollow(FOLLOW_initialiser_in_variableDeclaration4995);
                    initialiser();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(141);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 49, variableDeclaration_StartIndex); }
        }
        dbg.location(916, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "variableDeclaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "variableDeclaration"


    // $ANTLR start "variableDeclarationNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:918:1: variableDeclarationNoIn : Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( initialiserNoIn )? ;
    public final void variableDeclarationNoIn() throws RecognitionException {
        int variableDeclarationNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "variableDeclarationNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(918, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 50) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:2: ( Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( initialiserNoIn )? )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:4: Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( initialiserNoIn )?
            {
            dbg.location(919,4);
            match(input,Identifier,FOLLOW_Identifier_in_variableDeclarationNoIn5007); if (state.failed) return ;
            dbg.location(919,15);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:15: ( LineTerminator )*
            try { dbg.enterSubRule(142);

            loop142:
            do {
                int alt142=2;
                try { dbg.enterDecision(142);

                int LA142_0 = input.LA(1);

                if ( (LA142_0==LineTerminator) ) {
                    int LA142_2 = input.LA(2);

                    if ( (synpred216_AS3()) ) {
                        alt142=1;
                    }


                }


                } finally {dbg.exitDecision(142);}

                switch (alt142) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(919,15);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableDeclarationNoIn5009); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop142;
                }
            } while (true);
            } finally {dbg.exitSubRule(142);}

            dbg.location(919,31);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:31: ( typeInformation )?
            int alt143=2;
            try { dbg.enterSubRule(143);
            try { dbg.enterDecision(143);

            int LA143_0 = input.LA(1);

            if ( (LA143_0==43) ) {
                alt143=1;
            }
            } finally {dbg.exitDecision(143);}

            switch (alt143) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: typeInformation
                    {
                    dbg.location(919,31);
                    pushFollow(FOLLOW_typeInformation_in_variableDeclarationNoIn5012);
                    typeInformation();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(143);}

            dbg.location(919,48);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:48: ( LineTerminator )*
            try { dbg.enterSubRule(144);

            loop144:
            do {
                int alt144=2;
                try { dbg.enterDecision(144);

                int LA144_0 = input.LA(1);

                if ( (LA144_0==LineTerminator) ) {
                    int LA144_2 = input.LA(2);

                    if ( (synpred218_AS3()) ) {
                        alt144=1;
                    }


                }


                } finally {dbg.exitDecision(144);}

                switch (alt144) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(919,48);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_variableDeclarationNoIn5015); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop144;
                }
            } while (true);
            } finally {dbg.exitSubRule(144);}

            dbg.location(919,64);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:64: ( initialiserNoIn )?
            int alt145=2;
            try { dbg.enterSubRule(145);
            try { dbg.enterDecision(145);

            int LA145_0 = input.LA(1);

            if ( (LA145_0==80) ) {
                alt145=1;
            }
            } finally {dbg.exitDecision(145);}

            switch (alt145) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: initialiserNoIn
                    {
                    dbg.location(919,64);
                    pushFollow(FOLLOW_initialiserNoIn_in_variableDeclarationNoIn5018);
                    initialiserNoIn();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(145);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 50, variableDeclarationNoIn_StartIndex); }
        }
        dbg.location(920, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "variableDeclarationNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "variableDeclarationNoIn"


    // $ANTLR start "initialiser"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:922:1: initialiser : '=' ( LineTerminator )* assignmentExpression ;
    public final void initialiser() throws RecognitionException {
        int initialiser_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "initialiser");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(922, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 51) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:923:2: ( '=' ( LineTerminator )* assignmentExpression )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:923:4: '=' ( LineTerminator )* assignmentExpression
            {
            dbg.location(923,4);
            match(input,80,FOLLOW_80_in_initialiser5030); if (state.failed) return ;
            dbg.location(923,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:923:8: ( LineTerminator )*
            try { dbg.enterSubRule(146);

            loop146:
            do {
                int alt146=2;
                try { dbg.enterDecision(146);

                int LA146_0 = input.LA(1);

                if ( (LA146_0==LineTerminator) ) {
                    alt146=1;
                }


                } finally {dbg.exitDecision(146);}

                switch (alt146) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(923,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_initialiser5032); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop146;
                }
            } while (true);
            } finally {dbg.exitSubRule(146);}

            dbg.location(923,24);
            pushFollow(FOLLOW_assignmentExpression_in_initialiser5035);
            assignmentExpression();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 51, initialiser_StartIndex); }
        }
        dbg.location(924, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "initialiser");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "initialiser"


    // $ANTLR start "initialiserNoIn"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:926:1: initialiserNoIn : '=' ( LineTerminator )* assignmentExpressionNoIn ;
    public final void initialiserNoIn() throws RecognitionException {
        int initialiserNoIn_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "initialiserNoIn");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(926, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 52) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:927:2: ( '=' ( LineTerminator )* assignmentExpressionNoIn )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:927:4: '=' ( LineTerminator )* assignmentExpressionNoIn
            {
            dbg.location(927,4);
            match(input,80,FOLLOW_80_in_initialiserNoIn5047); if (state.failed) return ;
            dbg.location(927,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:927:8: ( LineTerminator )*
            try { dbg.enterSubRule(147);

            loop147:
            do {
                int alt147=2;
                try { dbg.enterDecision(147);

                int LA147_0 = input.LA(1);

                if ( (LA147_0==LineTerminator) ) {
                    alt147=1;
                }


                } finally {dbg.exitDecision(147);}

                switch (alt147) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(927,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_initialiserNoIn5049); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop147;
                }
            } while (true);
            } finally {dbg.exitSubRule(147);}

            dbg.location(927,24);
            pushFollow(FOLLOW_assignmentExpressionNoIn_in_initialiserNoIn5052);
            assignmentExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 52, initialiserNoIn_StartIndex); }
        }
        dbg.location(928, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "initialiserNoIn");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "initialiserNoIn"


    // $ANTLR start "emptyStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:930:1: emptyStatement : ';' ;
    public final void emptyStatement() throws RecognitionException {
        int emptyStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "emptyStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(930, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 53) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:931:2: ( ';' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:931:4: ';'
            {
            dbg.location(931,4);
            match(input,94,FOLLOW_94_in_emptyStatement5064); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 53, emptyStatement_StartIndex); }
        }
        dbg.location(932, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "emptyStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "emptyStatement"


    // $ANTLR start "expressionStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:934:1: expressionStatement : expression ( ( LineTerminator )* | ';' ) ;
    public final void expressionStatement() throws RecognitionException {
        int expressionStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "expressionStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(934, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 54) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:2: ( expression ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:4: expression ( ( LineTerminator )* | ';' )
            {
            dbg.location(935,4);
            pushFollow(FOLLOW_expression_in_expressionStatement5076);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(935,15);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:15: ( ( LineTerminator )* | ';' )
            int alt149=2;
            try { dbg.enterSubRule(149);
            try { dbg.enterDecision(149);

            int LA149_0 = input.LA(1);

            if ( (LA149_0==EOF||LA149_0==LineTerminator||LA149_0==Identifier||(LA149_0>=NullLiteral && LA149_0<=StringLiteral)||(LA149_0>=34 && LA149_0<=36)||LA149_0==38||(LA149_0>=41 && LA149_0<=42)||LA149_0==44||(LA149_0>=47 && LA149_0<=56)||(LA149_0>=92 && LA149_0<=93)||(LA149_0>=95 && LA149_0<=108)||LA149_0==111||LA149_0==116||(LA149_0>=118 && LA149_0<=120)||(LA149_0>=125 && LA149_0<=127)||(LA149_0>=129 && LA149_0<=131)) ) {
                alt149=1;
            }
            else if ( (LA149_0==94) ) {
                int LA149_2 = input.LA(2);

                if ( (synpred223_AS3()) ) {
                    alt149=1;
                }
                else if ( (true) ) {
                    alt149=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 149, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 149, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(149);}

            switch (alt149) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:16: ( LineTerminator )*
                    {
                    dbg.location(935,16);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:16: ( LineTerminator )*
                    try { dbg.enterSubRule(148);

                    loop148:
                    do {
                        int alt148=2;
                        try { dbg.enterDecision(148);

                        int LA148_0 = input.LA(1);

                        if ( (LA148_0==LineTerminator) ) {
                            int LA148_1 = input.LA(2);

                            if ( (synpred222_AS3()) ) {
                                alt148=1;
                            }


                        }


                        } finally {dbg.exitDecision(148);}

                        switch (alt148) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(935,16);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_expressionStatement5079); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop148;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(148);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:34: ';'
                    {
                    dbg.location(935,34);
                    match(input,94,FOLLOW_94_in_expressionStatement5084); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(149);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 54, expressionStatement_StartIndex); }
        }
        dbg.location(936, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "expressionStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "expressionStatement"


    // $ANTLR start "ifStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:938:1: ifStatement : 'if' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement ( ( LineTerminator )* 'else' ( LineTerminator )* statement )? ;
    public final void ifStatement() throws RecognitionException {
        int ifStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "ifStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(938, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:2: ( 'if' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement ( ( LineTerminator )* 'else' ( LineTerminator )* statement )? )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:4: 'if' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement ( ( LineTerminator )* 'else' ( LineTerminator )* statement )?
            {
            dbg.location(939,4);
            match(input,95,FOLLOW_95_in_ifStatement5096); if (state.failed) return ;
            dbg.location(939,9);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:9: ( LineTerminator )*
            try { dbg.enterSubRule(150);

            loop150:
            do {
                int alt150=2;
                try { dbg.enterDecision(150);

                int LA150_0 = input.LA(1);

                if ( (LA150_0==LineTerminator) ) {
                    alt150=1;
                }


                } finally {dbg.exitDecision(150);}

                switch (alt150) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(939,9);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_ifStatement5098); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop150;
                }
            } while (true);
            } finally {dbg.exitSubRule(150);}

            dbg.location(939,25);
            match(input,36,FOLLOW_36_in_ifStatement5101); if (state.failed) return ;
            dbg.location(939,29);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:29: ( LineTerminator )*
            try { dbg.enterSubRule(151);

            loop151:
            do {
                int alt151=2;
                try { dbg.enterDecision(151);

                int LA151_0 = input.LA(1);

                if ( (LA151_0==LineTerminator) ) {
                    alt151=1;
                }


                } finally {dbg.exitDecision(151);}

                switch (alt151) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(939,29);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_ifStatement5103); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop151;
                }
            } while (true);
            } finally {dbg.exitSubRule(151);}

            dbg.location(939,45);
            pushFollow(FOLLOW_expression_in_ifStatement5106);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(939,56);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:56: ( LineTerminator )*
            try { dbg.enterSubRule(152);

            loop152:
            do {
                int alt152=2;
                try { dbg.enterDecision(152);

                int LA152_0 = input.LA(1);

                if ( (LA152_0==LineTerminator) ) {
                    alt152=1;
                }


                } finally {dbg.exitDecision(152);}

                switch (alt152) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(939,56);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_ifStatement5108); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop152;
                }
            } while (true);
            } finally {dbg.exitSubRule(152);}

            dbg.location(939,72);
            match(input,37,FOLLOW_37_in_ifStatement5111); if (state.failed) return ;
            dbg.location(939,76);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:76: ( LineTerminator )*
            try { dbg.enterSubRule(153);

            loop153:
            do {
                int alt153=2;
                try { dbg.enterDecision(153);

                int LA153_0 = input.LA(1);

                if ( (LA153_0==LineTerminator) ) {
                    alt153=1;
                }


                } finally {dbg.exitDecision(153);}

                switch (alt153) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(939,76);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_ifStatement5113); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop153;
                }
            } while (true);
            } finally {dbg.exitSubRule(153);}

            dbg.location(939,92);
            pushFollow(FOLLOW_statement_in_ifStatement5116);
            statement();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(939,102);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:102: ( ( LineTerminator )* 'else' ( LineTerminator )* statement )?
            int alt156=2;
            try { dbg.enterSubRule(156);
            try { dbg.enterDecision(156);

            int LA156_0 = input.LA(1);

            if ( (LA156_0==LineTerminator) ) {
                int LA156_1 = input.LA(2);

                if ( (synpred230_AS3()) ) {
                    alt156=1;
                }
            }
            else if ( (LA156_0==96) ) {
                int LA156_2 = input.LA(2);

                if ( (synpred230_AS3()) ) {
                    alt156=1;
                }
            }
            } finally {dbg.exitDecision(156);}

            switch (alt156) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:103: ( LineTerminator )* 'else' ( LineTerminator )* statement
                    {
                    dbg.location(939,103);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:103: ( LineTerminator )*
                    try { dbg.enterSubRule(154);

                    loop154:
                    do {
                        int alt154=2;
                        try { dbg.enterDecision(154);

                        int LA154_0 = input.LA(1);

                        if ( (LA154_0==LineTerminator) ) {
                            alt154=1;
                        }


                        } finally {dbg.exitDecision(154);}

                        switch (alt154) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(939,103);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_ifStatement5119); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop154;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(154);}

                    dbg.location(939,119);
                    match(input,96,FOLLOW_96_in_ifStatement5122); if (state.failed) return ;
                    dbg.location(939,126);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:126: ( LineTerminator )*
                    try { dbg.enterSubRule(155);

                    loop155:
                    do {
                        int alt155=2;
                        try { dbg.enterDecision(155);

                        int LA155_0 = input.LA(1);

                        if ( (LA155_0==LineTerminator) ) {
                            alt155=1;
                        }


                        } finally {dbg.exitDecision(155);}

                        switch (alt155) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(939,126);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_ifStatement5124); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop155;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(155);}

                    dbg.location(939,142);
                    pushFollow(FOLLOW_statement_in_ifStatement5127);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(156);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 55, ifStatement_StartIndex); }
        }
        dbg.location(940, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "ifStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "ifStatement"


    // $ANTLR start "iterationStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:942:1: iterationStatement : ( doWhileStatement | whileStatement | forStatement | forInStatement );
    public final void iterationStatement() throws RecognitionException {
        int iterationStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "iterationStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(942, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 56) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:943:2: ( doWhileStatement | whileStatement | forStatement | forInStatement )
            int alt157=4;
            try { dbg.enterDecision(157);

            switch ( input.LA(1) ) {
            case 97:
                {
                alt157=1;
                }
                break;
            case 98:
                {
                alt157=2;
                }
                break;
            case 99:
                {
                int LA157_3 = input.LA(2);

                if ( (synpred233_AS3()) ) {
                    alt157=3;
                }
                else if ( (true) ) {
                    alt157=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 157, 3, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 157, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(157);}

            switch (alt157) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:943:4: doWhileStatement
                    {
                    dbg.location(943,4);
                    pushFollow(FOLLOW_doWhileStatement_in_iterationStatement5140);
                    doWhileStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:944:4: whileStatement
                    {
                    dbg.location(944,4);
                    pushFollow(FOLLOW_whileStatement_in_iterationStatement5145);
                    whileStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:945:4: forStatement
                    {
                    dbg.location(945,4);
                    pushFollow(FOLLOW_forStatement_in_iterationStatement5150);
                    forStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:946:4: forInStatement
                    {
                    dbg.location(946,4);
                    pushFollow(FOLLOW_forInStatement_in_iterationStatement5155);
                    forInStatement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 56, iterationStatement_StartIndex); }
        }
        dbg.location(947, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "iterationStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "iterationStatement"


    // $ANTLR start "doWhileStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:949:1: doWhileStatement : 'do' ( LineTerminator )* statement ( LineTerminator )* 'while' ( LineTerminator )* '(' expression ')' ( ( LineTerminator )* | ';' ) ;
    public final void doWhileStatement() throws RecognitionException {
        int doWhileStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "doWhileStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(949, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 57) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:2: ( 'do' ( LineTerminator )* statement ( LineTerminator )* 'while' ( LineTerminator )* '(' expression ')' ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:4: 'do' ( LineTerminator )* statement ( LineTerminator )* 'while' ( LineTerminator )* '(' expression ')' ( ( LineTerminator )* | ';' )
            {
            dbg.location(950,4);
            match(input,97,FOLLOW_97_in_doWhileStatement5167); if (state.failed) return ;
            dbg.location(950,9);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:9: ( LineTerminator )*
            try { dbg.enterSubRule(158);

            loop158:
            do {
                int alt158=2;
                try { dbg.enterDecision(158);

                int LA158_0 = input.LA(1);

                if ( (LA158_0==LineTerminator) ) {
                    alt158=1;
                }


                } finally {dbg.exitDecision(158);}

                switch (alt158) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(950,9);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_doWhileStatement5169); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop158;
                }
            } while (true);
            } finally {dbg.exitSubRule(158);}

            dbg.location(950,25);
            pushFollow(FOLLOW_statement_in_doWhileStatement5172);
            statement();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(950,35);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:35: ( LineTerminator )*
            try { dbg.enterSubRule(159);

            loop159:
            do {
                int alt159=2;
                try { dbg.enterDecision(159);

                int LA159_0 = input.LA(1);

                if ( (LA159_0==LineTerminator) ) {
                    alt159=1;
                }


                } finally {dbg.exitDecision(159);}

                switch (alt159) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(950,35);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_doWhileStatement5174); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop159;
                }
            } while (true);
            } finally {dbg.exitSubRule(159);}

            dbg.location(950,51);
            match(input,98,FOLLOW_98_in_doWhileStatement5177); if (state.failed) return ;
            dbg.location(950,59);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:59: ( LineTerminator )*
            try { dbg.enterSubRule(160);

            loop160:
            do {
                int alt160=2;
                try { dbg.enterDecision(160);

                int LA160_0 = input.LA(1);

                if ( (LA160_0==LineTerminator) ) {
                    alt160=1;
                }


                } finally {dbg.exitDecision(160);}

                switch (alt160) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(950,59);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_doWhileStatement5179); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop160;
                }
            } while (true);
            } finally {dbg.exitSubRule(160);}

            dbg.location(950,75);
            match(input,36,FOLLOW_36_in_doWhileStatement5182); if (state.failed) return ;
            dbg.location(950,79);
            pushFollow(FOLLOW_expression_in_doWhileStatement5184);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(950,90);
            match(input,37,FOLLOW_37_in_doWhileStatement5186); if (state.failed) return ;
            dbg.location(950,94);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:94: ( ( LineTerminator )* | ';' )
            int alt162=2;
            try { dbg.enterSubRule(162);
            try { dbg.enterDecision(162);

            int LA162_0 = input.LA(1);

            if ( (LA162_0==EOF||LA162_0==LineTerminator||LA162_0==Identifier||(LA162_0>=NullLiteral && LA162_0<=StringLiteral)||(LA162_0>=34 && LA162_0<=36)||LA162_0==38||(LA162_0>=41 && LA162_0<=42)||LA162_0==44||(LA162_0>=47 && LA162_0<=56)||(LA162_0>=92 && LA162_0<=93)||(LA162_0>=95 && LA162_0<=108)||LA162_0==111||LA162_0==116||(LA162_0>=118 && LA162_0<=120)||(LA162_0>=125 && LA162_0<=127)||(LA162_0>=129 && LA162_0<=131)) ) {
                alt162=1;
            }
            else if ( (LA162_0==94) ) {
                int LA162_2 = input.LA(2);

                if ( (synpred238_AS3()) ) {
                    alt162=1;
                }
                else if ( (true) ) {
                    alt162=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 162, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 162, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(162);}

            switch (alt162) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:95: ( LineTerminator )*
                    {
                    dbg.location(950,95);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:95: ( LineTerminator )*
                    try { dbg.enterSubRule(161);

                    loop161:
                    do {
                        int alt161=2;
                        try { dbg.enterDecision(161);

                        int LA161_0 = input.LA(1);

                        if ( (LA161_0==LineTerminator) ) {
                            int LA161_1 = input.LA(2);

                            if ( (synpred237_AS3()) ) {
                                alt161=1;
                            }


                        }


                        } finally {dbg.exitDecision(161);}

                        switch (alt161) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(950,95);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_doWhileStatement5189); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop161;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(161);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:113: ';'
                    {
                    dbg.location(950,113);
                    match(input,94,FOLLOW_94_in_doWhileStatement5194); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(162);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 57, doWhileStatement_StartIndex); }
        }
        dbg.location(951, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "doWhileStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "doWhileStatement"


    // $ANTLR start "whileStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:953:1: whileStatement : 'while' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement ;
    public final void whileStatement() throws RecognitionException {
        int whileStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "whileStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(953, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 58) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:954:2: ( 'while' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:954:4: 'while' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement
            {
            dbg.location(954,4);
            match(input,98,FOLLOW_98_in_whileStatement5207); if (state.failed) return ;
            dbg.location(954,12);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:954:12: ( LineTerminator )*
            try { dbg.enterSubRule(163);

            loop163:
            do {
                int alt163=2;
                try { dbg.enterDecision(163);

                int LA163_0 = input.LA(1);

                if ( (LA163_0==LineTerminator) ) {
                    alt163=1;
                }


                } finally {dbg.exitDecision(163);}

                switch (alt163) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(954,12);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_whileStatement5209); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop163;
                }
            } while (true);
            } finally {dbg.exitSubRule(163);}

            dbg.location(954,28);
            match(input,36,FOLLOW_36_in_whileStatement5212); if (state.failed) return ;
            dbg.location(954,32);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:954:32: ( LineTerminator )*
            try { dbg.enterSubRule(164);

            loop164:
            do {
                int alt164=2;
                try { dbg.enterDecision(164);

                int LA164_0 = input.LA(1);

                if ( (LA164_0==LineTerminator) ) {
                    alt164=1;
                }


                } finally {dbg.exitDecision(164);}

                switch (alt164) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(954,32);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_whileStatement5214); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop164;
                }
            } while (true);
            } finally {dbg.exitSubRule(164);}

            dbg.location(954,48);
            pushFollow(FOLLOW_expression_in_whileStatement5217);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(954,59);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:954:59: ( LineTerminator )*
            try { dbg.enterSubRule(165);

            loop165:
            do {
                int alt165=2;
                try { dbg.enterDecision(165);

                int LA165_0 = input.LA(1);

                if ( (LA165_0==LineTerminator) ) {
                    alt165=1;
                }


                } finally {dbg.exitDecision(165);}

                switch (alt165) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(954,59);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_whileStatement5219); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop165;
                }
            } while (true);
            } finally {dbg.exitSubRule(165);}

            dbg.location(954,75);
            match(input,37,FOLLOW_37_in_whileStatement5222); if (state.failed) return ;
            dbg.location(954,79);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:954:79: ( LineTerminator )*
            try { dbg.enterSubRule(166);

            loop166:
            do {
                int alt166=2;
                try { dbg.enterDecision(166);

                int LA166_0 = input.LA(1);

                if ( (LA166_0==LineTerminator) ) {
                    alt166=1;
                }


                } finally {dbg.exitDecision(166);}

                switch (alt166) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(954,79);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_whileStatement5224); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop166;
                }
            } while (true);
            } finally {dbg.exitSubRule(166);}

            dbg.location(954,95);
            pushFollow(FOLLOW_statement_in_whileStatement5227);
            statement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 58, whileStatement_StartIndex); }
        }
        dbg.location(955, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "whileStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "whileStatement"


    // $ANTLR start "forStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:957:1: forStatement : 'for' ( LineTerminator )* '(' ( ( LineTerminator )* forStatementInitialiserPart )? ( LineTerminator )* ';' ( ( LineTerminator )* expression )? ( LineTerminator )* ';' ( ( LineTerminator )* expression )? ( LineTerminator )* ')' ( LineTerminator )* statement ;
    public final void forStatement() throws RecognitionException {
        int forStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "forStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(957, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 59) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:2: ( 'for' ( LineTerminator )* '(' ( ( LineTerminator )* forStatementInitialiserPart )? ( LineTerminator )* ';' ( ( LineTerminator )* expression )? ( LineTerminator )* ';' ( ( LineTerminator )* expression )? ( LineTerminator )* ')' ( LineTerminator )* statement )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:4: 'for' ( LineTerminator )* '(' ( ( LineTerminator )* forStatementInitialiserPart )? ( LineTerminator )* ';' ( ( LineTerminator )* expression )? ( LineTerminator )* ';' ( ( LineTerminator )* expression )? ( LineTerminator )* ')' ( LineTerminator )* statement
            {
            dbg.location(958,4);
            match(input,99,FOLLOW_99_in_forStatement5239); if (state.failed) return ;
            dbg.location(958,10);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:10: ( LineTerminator )*
            try { dbg.enterSubRule(167);

            loop167:
            do {
                int alt167=2;
                try { dbg.enterDecision(167);

                int LA167_0 = input.LA(1);

                if ( (LA167_0==LineTerminator) ) {
                    alt167=1;
                }


                } finally {dbg.exitDecision(167);}

                switch (alt167) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(958,10);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatement5241); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop167;
                }
            } while (true);
            } finally {dbg.exitSubRule(167);}

            dbg.location(958,26);
            match(input,36,FOLLOW_36_in_forStatement5244); if (state.failed) return ;
            dbg.location(958,30);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:30: ( ( LineTerminator )* forStatementInitialiserPart )?
            int alt169=2;
            try { dbg.enterSubRule(169);
            try { dbg.enterDecision(169);

            try {
                isCyclicDecision = true;
                alt169 = dfa169.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(169);}

            switch (alt169) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:31: ( LineTerminator )* forStatementInitialiserPart
                    {
                    dbg.location(958,31);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:31: ( LineTerminator )*
                    try { dbg.enterSubRule(168);

                    loop168:
                    do {
                        int alt168=2;
                        try { dbg.enterDecision(168);

                        int LA168_0 = input.LA(1);

                        if ( (LA168_0==LineTerminator) ) {
                            alt168=1;
                        }


                        } finally {dbg.exitDecision(168);}

                        switch (alt168) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(958,31);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatement5247); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop168;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(168);}

                    dbg.location(958,47);
                    pushFollow(FOLLOW_forStatementInitialiserPart_in_forStatement5250);
                    forStatementInitialiserPart();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(169);}

            dbg.location(958,77);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:77: ( LineTerminator )*
            try { dbg.enterSubRule(170);

            loop170:
            do {
                int alt170=2;
                try { dbg.enterDecision(170);

                int LA170_0 = input.LA(1);

                if ( (LA170_0==LineTerminator) ) {
                    alt170=1;
                }


                } finally {dbg.exitDecision(170);}

                switch (alt170) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(958,77);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatement5254); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop170;
                }
            } while (true);
            } finally {dbg.exitSubRule(170);}

            dbg.location(958,93);
            match(input,94,FOLLOW_94_in_forStatement5257); if (state.failed) return ;
            dbg.location(958,97);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:97: ( ( LineTerminator )* expression )?
            int alt172=2;
            try { dbg.enterSubRule(172);
            try { dbg.enterDecision(172);

            try {
                isCyclicDecision = true;
                alt172 = dfa172.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(172);}

            switch (alt172) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:98: ( LineTerminator )* expression
                    {
                    dbg.location(958,98);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:98: ( LineTerminator )*
                    try { dbg.enterSubRule(171);

                    loop171:
                    do {
                        int alt171=2;
                        try { dbg.enterDecision(171);

                        int LA171_0 = input.LA(1);

                        if ( (LA171_0==LineTerminator) ) {
                            alt171=1;
                        }


                        } finally {dbg.exitDecision(171);}

                        switch (alt171) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(958,98);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatement5260); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop171;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(171);}

                    dbg.location(958,114);
                    pushFollow(FOLLOW_expression_in_forStatement5263);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(172);}

            dbg.location(958,127);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:127: ( LineTerminator )*
            try { dbg.enterSubRule(173);

            loop173:
            do {
                int alt173=2;
                try { dbg.enterDecision(173);

                int LA173_0 = input.LA(1);

                if ( (LA173_0==LineTerminator) ) {
                    alt173=1;
                }


                } finally {dbg.exitDecision(173);}

                switch (alt173) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(958,127);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatement5267); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop173;
                }
            } while (true);
            } finally {dbg.exitSubRule(173);}

            dbg.location(958,143);
            match(input,94,FOLLOW_94_in_forStatement5270); if (state.failed) return ;
            dbg.location(958,147);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:147: ( ( LineTerminator )* expression )?
            int alt175=2;
            try { dbg.enterSubRule(175);
            try { dbg.enterDecision(175);

            try {
                isCyclicDecision = true;
                alt175 = dfa175.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(175);}

            switch (alt175) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:148: ( LineTerminator )* expression
                    {
                    dbg.location(958,148);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:148: ( LineTerminator )*
                    try { dbg.enterSubRule(174);

                    loop174:
                    do {
                        int alt174=2;
                        try { dbg.enterDecision(174);

                        int LA174_0 = input.LA(1);

                        if ( (LA174_0==LineTerminator) ) {
                            alt174=1;
                        }


                        } finally {dbg.exitDecision(174);}

                        switch (alt174) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(958,148);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatement5273); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop174;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(174);}

                    dbg.location(958,164);
                    pushFollow(FOLLOW_expression_in_forStatement5276);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(175);}

            dbg.location(958,177);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:177: ( LineTerminator )*
            try { dbg.enterSubRule(176);

            loop176:
            do {
                int alt176=2;
                try { dbg.enterDecision(176);

                int LA176_0 = input.LA(1);

                if ( (LA176_0==LineTerminator) ) {
                    alt176=1;
                }


                } finally {dbg.exitDecision(176);}

                switch (alt176) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(958,177);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatement5280); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop176;
                }
            } while (true);
            } finally {dbg.exitSubRule(176);}

            dbg.location(958,193);
            match(input,37,FOLLOW_37_in_forStatement5283); if (state.failed) return ;
            dbg.location(958,197);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:958:197: ( LineTerminator )*
            try { dbg.enterSubRule(177);

            loop177:
            do {
                int alt177=2;
                try { dbg.enterDecision(177);

                int LA177_0 = input.LA(1);

                if ( (LA177_0==LineTerminator) ) {
                    alt177=1;
                }


                } finally {dbg.exitDecision(177);}

                switch (alt177) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(958,197);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatement5285); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop177;
                }
            } while (true);
            } finally {dbg.exitSubRule(177);}

            dbg.location(958,213);
            pushFollow(FOLLOW_statement_in_forStatement5288);
            statement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 59, forStatement_StartIndex); }
        }
        dbg.location(959, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "forStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "forStatement"


    // $ANTLR start "forStatementInitialiserPart"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:961:1: forStatementInitialiserPart : ( expressionNoIn | 'var' ( LineTerminator )* variableDeclarationListNoIn );
    public final void forStatementInitialiserPart() throws RecognitionException {
        int forStatementInitialiserPart_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "forStatementInitialiserPart");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(961, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 60) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:962:2: ( expressionNoIn | 'var' ( LineTerminator )* variableDeclarationListNoIn )
            int alt179=2;
            try { dbg.enterDecision(179);

            int LA179_0 = input.LA(1);

            if ( (LA179_0==Identifier||(LA179_0>=NullLiteral && LA179_0<=StringLiteral)||(LA179_0>=34 && LA179_0<=36)||LA179_0==38||LA179_0==41||LA179_0==44||(LA179_0>=47 && LA179_0<=56)||LA179_0==111) ) {
                alt179=1;
            }
            else if ( (LA179_0==92) ) {
                alt179=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 179, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(179);}

            switch (alt179) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:962:4: expressionNoIn
                    {
                    dbg.location(962,4);
                    pushFollow(FOLLOW_expressionNoIn_in_forStatementInitialiserPart5300);
                    expressionNoIn();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:963:4: 'var' ( LineTerminator )* variableDeclarationListNoIn
                    {
                    dbg.location(963,4);
                    match(input,92,FOLLOW_92_in_forStatementInitialiserPart5305); if (state.failed) return ;
                    dbg.location(963,10);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:963:10: ( LineTerminator )*
                    try { dbg.enterSubRule(178);

                    loop178:
                    do {
                        int alt178=2;
                        try { dbg.enterDecision(178);

                        int LA178_0 = input.LA(1);

                        if ( (LA178_0==LineTerminator) ) {
                            alt178=1;
                        }


                        } finally {dbg.exitDecision(178);}

                        switch (alt178) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(963,10);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forStatementInitialiserPart5307); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop178;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(178);}

                    dbg.location(963,26);
                    pushFollow(FOLLOW_variableDeclarationListNoIn_in_forStatementInitialiserPart5310);
                    variableDeclarationListNoIn();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 60, forStatementInitialiserPart_StartIndex); }
        }
        dbg.location(964, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "forStatementInitialiserPart");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "forStatementInitialiserPart"


    // $ANTLR start "forInStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:966:1: forInStatement : 'for' ( LineTerminator )* '(' ( LineTerminator )* forInStatementInitialiserPart ( LineTerminator )* 'in' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement ;
    public final void forInStatement() throws RecognitionException {
        int forInStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "forInStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(966, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 61) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:967:2: ( 'for' ( LineTerminator )* '(' ( LineTerminator )* forInStatementInitialiserPart ( LineTerminator )* 'in' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:967:4: 'for' ( LineTerminator )* '(' ( LineTerminator )* forInStatementInitialiserPart ( LineTerminator )* 'in' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement
            {
            dbg.location(967,4);
            match(input,99,FOLLOW_99_in_forInStatement5322); if (state.failed) return ;
            dbg.location(967,10);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:967:10: ( LineTerminator )*
            try { dbg.enterSubRule(180);

            loop180:
            do {
                int alt180=2;
                try { dbg.enterDecision(180);

                int LA180_0 = input.LA(1);

                if ( (LA180_0==LineTerminator) ) {
                    alt180=1;
                }


                } finally {dbg.exitDecision(180);}

                switch (alt180) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(967,10);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forInStatement5324); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop180;
                }
            } while (true);
            } finally {dbg.exitSubRule(180);}

            dbg.location(967,26);
            match(input,36,FOLLOW_36_in_forInStatement5327); if (state.failed) return ;
            dbg.location(967,30);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:967:30: ( LineTerminator )*
            try { dbg.enterSubRule(181);

            loop181:
            do {
                int alt181=2;
                try { dbg.enterDecision(181);

                int LA181_0 = input.LA(1);

                if ( (LA181_0==LineTerminator) ) {
                    alt181=1;
                }


                } finally {dbg.exitDecision(181);}

                switch (alt181) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(967,30);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forInStatement5329); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop181;
                }
            } while (true);
            } finally {dbg.exitSubRule(181);}

            dbg.location(967,46);
            pushFollow(FOLLOW_forInStatementInitialiserPart_in_forInStatement5332);
            forInStatementInitialiserPart();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(967,76);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:967:76: ( LineTerminator )*
            try { dbg.enterSubRule(182);

            loop182:
            do {
                int alt182=2;
                try { dbg.enterDecision(182);

                int LA182_0 = input.LA(1);

                if ( (LA182_0==LineTerminator) ) {
                    alt182=1;
                }


                } finally {dbg.exitDecision(182);}

                switch (alt182) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(967,76);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forInStatement5334); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop182;
                }
            } while (true);
            } finally {dbg.exitSubRule(182);}

            dbg.location(967,92);
            match(input,69,FOLLOW_69_in_forInStatement5337); if (state.failed) return ;
            dbg.location(967,97);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:967:97: ( LineTerminator )*
            try { dbg.enterSubRule(183);

            loop183:
            do {
                int alt183=2;
                try { dbg.enterDecision(183);

                int LA183_0 = input.LA(1);

                if ( (LA183_0==LineTerminator) ) {
                    alt183=1;
                }


                } finally {dbg.exitDecision(183);}

                switch (alt183) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(967,97);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forInStatement5339); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop183;
                }
            } while (true);
            } finally {dbg.exitSubRule(183);}

            dbg.location(967,113);
            pushFollow(FOLLOW_expression_in_forInStatement5342);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(967,124);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:967:124: ( LineTerminator )*
            try { dbg.enterSubRule(184);

            loop184:
            do {
                int alt184=2;
                try { dbg.enterDecision(184);

                int LA184_0 = input.LA(1);

                if ( (LA184_0==LineTerminator) ) {
                    alt184=1;
                }


                } finally {dbg.exitDecision(184);}

                switch (alt184) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(967,124);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forInStatement5344); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop184;
                }
            } while (true);
            } finally {dbg.exitSubRule(184);}

            dbg.location(967,140);
            match(input,37,FOLLOW_37_in_forInStatement5347); if (state.failed) return ;
            dbg.location(967,144);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:967:144: ( LineTerminator )*
            try { dbg.enterSubRule(185);

            loop185:
            do {
                int alt185=2;
                try { dbg.enterDecision(185);

                int LA185_0 = input.LA(1);

                if ( (LA185_0==LineTerminator) ) {
                    alt185=1;
                }


                } finally {dbg.exitDecision(185);}

                switch (alt185) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(967,144);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forInStatement5349); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop185;
                }
            } while (true);
            } finally {dbg.exitSubRule(185);}

            dbg.location(967,160);
            pushFollow(FOLLOW_statement_in_forInStatement5352);
            statement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 61, forInStatement_StartIndex); }
        }
        dbg.location(968, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "forInStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "forInStatement"


    // $ANTLR start "forInStatementInitialiserPart"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:970:1: forInStatementInitialiserPart : ( leftHandSideExpression | 'var' ( LineTerminator )* variableDeclarationNoIn );
    public final void forInStatementInitialiserPart() throws RecognitionException {
        int forInStatementInitialiserPart_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "forInStatementInitialiserPart");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(970, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:971:2: ( leftHandSideExpression | 'var' ( LineTerminator )* variableDeclarationNoIn )
            int alt187=2;
            try { dbg.enterDecision(187);

            int LA187_0 = input.LA(1);

            if ( (LA187_0==Identifier||(LA187_0>=NullLiteral && LA187_0<=StringLiteral)||(LA187_0>=34 && LA187_0<=36)||LA187_0==38||LA187_0==41||LA187_0==44||LA187_0==111) ) {
                alt187=1;
            }
            else if ( (LA187_0==92) ) {
                alt187=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 187, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(187);}

            switch (alt187) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:971:4: leftHandSideExpression
                    {
                    dbg.location(971,4);
                    pushFollow(FOLLOW_leftHandSideExpression_in_forInStatementInitialiserPart5364);
                    leftHandSideExpression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:972:4: 'var' ( LineTerminator )* variableDeclarationNoIn
                    {
                    dbg.location(972,4);
                    match(input,92,FOLLOW_92_in_forInStatementInitialiserPart5369); if (state.failed) return ;
                    dbg.location(972,10);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:972:10: ( LineTerminator )*
                    try { dbg.enterSubRule(186);

                    loop186:
                    do {
                        int alt186=2;
                        try { dbg.enterDecision(186);

                        int LA186_0 = input.LA(1);

                        if ( (LA186_0==LineTerminator) ) {
                            alt186=1;
                        }


                        } finally {dbg.exitDecision(186);}

                        switch (alt186) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(972,10);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_forInStatementInitialiserPart5371); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop186;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(186);}

                    dbg.location(972,26);
                    pushFollow(FOLLOW_variableDeclarationNoIn_in_forInStatementInitialiserPart5374);
                    variableDeclarationNoIn();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 62, forInStatementInitialiserPart_StartIndex); }
        }
        dbg.location(973, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "forInStatementInitialiserPart");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "forInStatementInitialiserPart"


    // $ANTLR start "continueStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:975:1: continueStatement : 'continue' ( Identifier )? ( ( LineTerminator )* | ';' ) ;
    public final void continueStatement() throws RecognitionException {
        int continueStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "continueStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(975, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 63) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:2: ( 'continue' ( Identifier )? ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:4: 'continue' ( Identifier )? ( ( LineTerminator )* | ';' )
            {
            dbg.location(976,4);
            match(input,100,FOLLOW_100_in_continueStatement5385); if (state.failed) return ;
            dbg.location(976,15);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:15: ( Identifier )?
            int alt188=2;
            try { dbg.enterSubRule(188);
            try { dbg.enterDecision(188);

            int LA188_0 = input.LA(1);

            if ( (LA188_0==Identifier) ) {
                int LA188_1 = input.LA(2);

                if ( (synpred264_AS3()) ) {
                    alt188=1;
                }
            }
            } finally {dbg.exitDecision(188);}

            switch (alt188) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: Identifier
                    {
                    dbg.location(976,15);
                    match(input,Identifier,FOLLOW_Identifier_in_continueStatement5387); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(188);}

            dbg.location(976,27);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:27: ( ( LineTerminator )* | ';' )
            int alt190=2;
            try { dbg.enterSubRule(190);
            try { dbg.enterDecision(190);

            int LA190_0 = input.LA(1);

            if ( (LA190_0==EOF||LA190_0==LineTerminator||LA190_0==Identifier||(LA190_0>=NullLiteral && LA190_0<=StringLiteral)||(LA190_0>=34 && LA190_0<=36)||LA190_0==38||(LA190_0>=41 && LA190_0<=42)||LA190_0==44||(LA190_0>=47 && LA190_0<=56)||(LA190_0>=92 && LA190_0<=93)||(LA190_0>=95 && LA190_0<=108)||LA190_0==111||LA190_0==116||(LA190_0>=118 && LA190_0<=120)||(LA190_0>=125 && LA190_0<=127)||(LA190_0>=129 && LA190_0<=131)) ) {
                alt190=1;
            }
            else if ( (LA190_0==94) ) {
                int LA190_2 = input.LA(2);

                if ( (synpred266_AS3()) ) {
                    alt190=1;
                }
                else if ( (true) ) {
                    alt190=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 190, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 190, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(190);}

            switch (alt190) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:28: ( LineTerminator )*
                    {
                    dbg.location(976,28);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:28: ( LineTerminator )*
                    try { dbg.enterSubRule(189);

                    loop189:
                    do {
                        int alt189=2;
                        try { dbg.enterDecision(189);

                        int LA189_0 = input.LA(1);

                        if ( (LA189_0==LineTerminator) ) {
                            int LA189_1 = input.LA(2);

                            if ( (synpred265_AS3()) ) {
                                alt189=1;
                            }


                        }


                        } finally {dbg.exitDecision(189);}

                        switch (alt189) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(976,28);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_continueStatement5391); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop189;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(189);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:46: ';'
                    {
                    dbg.location(976,46);
                    match(input,94,FOLLOW_94_in_continueStatement5396); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(190);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 63, continueStatement_StartIndex); }
        }
        dbg.location(977, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "continueStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "continueStatement"


    // $ANTLR start "breakStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:979:1: breakStatement : 'break' ( Identifier )? ( ( LineTerminator )* | ';' ) ;
    public final void breakStatement() throws RecognitionException {
        int breakStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "breakStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(979, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 64) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:2: ( 'break' ( Identifier )? ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:4: 'break' ( Identifier )? ( ( LineTerminator )* | ';' )
            {
            dbg.location(980,4);
            match(input,101,FOLLOW_101_in_breakStatement5408); if (state.failed) return ;
            dbg.location(980,12);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:12: ( Identifier )?
            int alt191=2;
            try { dbg.enterSubRule(191);
            try { dbg.enterDecision(191);

            int LA191_0 = input.LA(1);

            if ( (LA191_0==Identifier) ) {
                int LA191_1 = input.LA(2);

                if ( (synpred267_AS3()) ) {
                    alt191=1;
                }
            }
            } finally {dbg.exitDecision(191);}

            switch (alt191) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: Identifier
                    {
                    dbg.location(980,12);
                    match(input,Identifier,FOLLOW_Identifier_in_breakStatement5410); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(191);}

            dbg.location(980,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:24: ( ( LineTerminator )* | ';' )
            int alt193=2;
            try { dbg.enterSubRule(193);
            try { dbg.enterDecision(193);

            int LA193_0 = input.LA(1);

            if ( (LA193_0==EOF||LA193_0==LineTerminator||LA193_0==Identifier||(LA193_0>=NullLiteral && LA193_0<=StringLiteral)||(LA193_0>=34 && LA193_0<=36)||LA193_0==38||(LA193_0>=41 && LA193_0<=42)||LA193_0==44||(LA193_0>=47 && LA193_0<=56)||(LA193_0>=92 && LA193_0<=93)||(LA193_0>=95 && LA193_0<=108)||LA193_0==111||LA193_0==116||(LA193_0>=118 && LA193_0<=120)||(LA193_0>=125 && LA193_0<=127)||(LA193_0>=129 && LA193_0<=131)) ) {
                alt193=1;
            }
            else if ( (LA193_0==94) ) {
                int LA193_2 = input.LA(2);

                if ( (synpred269_AS3()) ) {
                    alt193=1;
                }
                else if ( (true) ) {
                    alt193=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 193, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 193, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(193);}

            switch (alt193) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:25: ( LineTerminator )*
                    {
                    dbg.location(980,25);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:25: ( LineTerminator )*
                    try { dbg.enterSubRule(192);

                    loop192:
                    do {
                        int alt192=2;
                        try { dbg.enterDecision(192);

                        int LA192_0 = input.LA(1);

                        if ( (LA192_0==LineTerminator) ) {
                            int LA192_1 = input.LA(2);

                            if ( (synpred268_AS3()) ) {
                                alt192=1;
                            }


                        }


                        } finally {dbg.exitDecision(192);}

                        switch (alt192) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(980,25);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_breakStatement5414); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop192;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(192);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:43: ';'
                    {
                    dbg.location(980,43);
                    match(input,94,FOLLOW_94_in_breakStatement5419); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(193);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 64, breakStatement_StartIndex); }
        }
        dbg.location(981, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "breakStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "breakStatement"


    // $ANTLR start "returnStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:983:1: returnStatement : 'return' ( expression )? ( ( LineTerminator )* | ';' ) ;
    public final void returnStatement() throws RecognitionException {
        int returnStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "returnStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(983, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 65) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:2: ( 'return' ( expression )? ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:4: 'return' ( expression )? ( ( LineTerminator )* | ';' )
            {
            dbg.location(984,4);
            match(input,102,FOLLOW_102_in_returnStatement5431); if (state.failed) return ;
            dbg.location(984,13);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:13: ( expression )?
            int alt194=2;
            try { dbg.enterSubRule(194);
            try { dbg.enterDecision(194);

            try {
                isCyclicDecision = true;
                alt194 = dfa194.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(194);}

            switch (alt194) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: expression
                    {
                    dbg.location(984,13);
                    pushFollow(FOLLOW_expression_in_returnStatement5433);
                    expression();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(194);}

            dbg.location(984,25);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:25: ( ( LineTerminator )* | ';' )
            int alt196=2;
            try { dbg.enterSubRule(196);
            try { dbg.enterDecision(196);

            int LA196_0 = input.LA(1);

            if ( (LA196_0==EOF||LA196_0==LineTerminator||LA196_0==Identifier||(LA196_0>=NullLiteral && LA196_0<=StringLiteral)||(LA196_0>=34 && LA196_0<=36)||LA196_0==38||(LA196_0>=41 && LA196_0<=42)||LA196_0==44||(LA196_0>=47 && LA196_0<=56)||(LA196_0>=92 && LA196_0<=93)||(LA196_0>=95 && LA196_0<=108)||LA196_0==111||LA196_0==116||(LA196_0>=118 && LA196_0<=120)||(LA196_0>=125 && LA196_0<=127)||(LA196_0>=129 && LA196_0<=131)) ) {
                alt196=1;
            }
            else if ( (LA196_0==94) ) {
                int LA196_2 = input.LA(2);

                if ( (synpred272_AS3()) ) {
                    alt196=1;
                }
                else if ( (true) ) {
                    alt196=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 196, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 196, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(196);}

            switch (alt196) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:26: ( LineTerminator )*
                    {
                    dbg.location(984,26);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:26: ( LineTerminator )*
                    try { dbg.enterSubRule(195);

                    loop195:
                    do {
                        int alt195=2;
                        try { dbg.enterDecision(195);

                        int LA195_0 = input.LA(1);

                        if ( (LA195_0==LineTerminator) ) {
                            int LA195_1 = input.LA(2);

                            if ( (synpred271_AS3()) ) {
                                alt195=1;
                            }


                        }


                        } finally {dbg.exitDecision(195);}

                        switch (alt195) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(984,26);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_returnStatement5437); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop195;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(195);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:44: ';'
                    {
                    dbg.location(984,44);
                    match(input,94,FOLLOW_94_in_returnStatement5442); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(196);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 65, returnStatement_StartIndex); }
        }
        dbg.location(985, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "returnStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "returnStatement"


    // $ANTLR start "withStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:987:1: withStatement : 'with' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement ;
    public final void withStatement() throws RecognitionException {
        int withStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "withStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(987, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 66) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:988:2: ( 'with' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:988:4: 'with' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* statement
            {
            dbg.location(988,4);
            match(input,103,FOLLOW_103_in_withStatement5455); if (state.failed) return ;
            dbg.location(988,11);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:988:11: ( LineTerminator )*
            try { dbg.enterSubRule(197);

            loop197:
            do {
                int alt197=2;
                try { dbg.enterDecision(197);

                int LA197_0 = input.LA(1);

                if ( (LA197_0==LineTerminator) ) {
                    alt197=1;
                }


                } finally {dbg.exitDecision(197);}

                switch (alt197) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(988,11);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_withStatement5457); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop197;
                }
            } while (true);
            } finally {dbg.exitSubRule(197);}

            dbg.location(988,27);
            match(input,36,FOLLOW_36_in_withStatement5460); if (state.failed) return ;
            dbg.location(988,31);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:988:31: ( LineTerminator )*
            try { dbg.enterSubRule(198);

            loop198:
            do {
                int alt198=2;
                try { dbg.enterDecision(198);

                int LA198_0 = input.LA(1);

                if ( (LA198_0==LineTerminator) ) {
                    alt198=1;
                }


                } finally {dbg.exitDecision(198);}

                switch (alt198) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(988,31);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_withStatement5462); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop198;
                }
            } while (true);
            } finally {dbg.exitSubRule(198);}

            dbg.location(988,47);
            pushFollow(FOLLOW_expression_in_withStatement5465);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(988,58);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:988:58: ( LineTerminator )*
            try { dbg.enterSubRule(199);

            loop199:
            do {
                int alt199=2;
                try { dbg.enterDecision(199);

                int LA199_0 = input.LA(1);

                if ( (LA199_0==LineTerminator) ) {
                    alt199=1;
                }


                } finally {dbg.exitDecision(199);}

                switch (alt199) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(988,58);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_withStatement5467); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop199;
                }
            } while (true);
            } finally {dbg.exitSubRule(199);}

            dbg.location(988,74);
            match(input,37,FOLLOW_37_in_withStatement5470); if (state.failed) return ;
            dbg.location(988,78);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:988:78: ( LineTerminator )*
            try { dbg.enterSubRule(200);

            loop200:
            do {
                int alt200=2;
                try { dbg.enterDecision(200);

                int LA200_0 = input.LA(1);

                if ( (LA200_0==LineTerminator) ) {
                    alt200=1;
                }


                } finally {dbg.exitDecision(200);}

                switch (alt200) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(988,78);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_withStatement5472); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop200;
                }
            } while (true);
            } finally {dbg.exitSubRule(200);}

            dbg.location(988,94);
            pushFollow(FOLLOW_statement_in_withStatement5475);
            statement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 66, withStatement_StartIndex); }
        }
        dbg.location(989, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "withStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "withStatement"


    // $ANTLR start "switchStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:991:1: switchStatement : 'switch' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* caseBlock ;
    public final void switchStatement() throws RecognitionException {
        int switchStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "switchStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(991, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 67) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:992:2: ( 'switch' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* caseBlock )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:992:4: 'switch' ( LineTerminator )* '(' ( LineTerminator )* expression ( LineTerminator )* ')' ( LineTerminator )* caseBlock
            {
            dbg.location(992,4);
            match(input,104,FOLLOW_104_in_switchStatement5487); if (state.failed) return ;
            dbg.location(992,13);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:992:13: ( LineTerminator )*
            try { dbg.enterSubRule(201);

            loop201:
            do {
                int alt201=2;
                try { dbg.enterDecision(201);

                int LA201_0 = input.LA(1);

                if ( (LA201_0==LineTerminator) ) {
                    alt201=1;
                }


                } finally {dbg.exitDecision(201);}

                switch (alt201) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(992,13);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_switchStatement5489); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop201;
                }
            } while (true);
            } finally {dbg.exitSubRule(201);}

            dbg.location(992,29);
            match(input,36,FOLLOW_36_in_switchStatement5492); if (state.failed) return ;
            dbg.location(992,33);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:992:33: ( LineTerminator )*
            try { dbg.enterSubRule(202);

            loop202:
            do {
                int alt202=2;
                try { dbg.enterDecision(202);

                int LA202_0 = input.LA(1);

                if ( (LA202_0==LineTerminator) ) {
                    alt202=1;
                }


                } finally {dbg.exitDecision(202);}

                switch (alt202) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(992,33);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_switchStatement5494); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop202;
                }
            } while (true);
            } finally {dbg.exitSubRule(202);}

            dbg.location(992,49);
            pushFollow(FOLLOW_expression_in_switchStatement5497);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(992,60);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:992:60: ( LineTerminator )*
            try { dbg.enterSubRule(203);

            loop203:
            do {
                int alt203=2;
                try { dbg.enterDecision(203);

                int LA203_0 = input.LA(1);

                if ( (LA203_0==LineTerminator) ) {
                    alt203=1;
                }


                } finally {dbg.exitDecision(203);}

                switch (alt203) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(992,60);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_switchStatement5499); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop203;
                }
            } while (true);
            } finally {dbg.exitSubRule(203);}

            dbg.location(992,76);
            match(input,37,FOLLOW_37_in_switchStatement5502); if (state.failed) return ;
            dbg.location(992,80);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:992:80: ( LineTerminator )*
            try { dbg.enterSubRule(204);

            loop204:
            do {
                int alt204=2;
                try { dbg.enterDecision(204);

                int LA204_0 = input.LA(1);

                if ( (LA204_0==LineTerminator) ) {
                    alt204=1;
                }


                } finally {dbg.exitDecision(204);}

                switch (alt204) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(992,80);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_switchStatement5504); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop204;
                }
            } while (true);
            } finally {dbg.exitSubRule(204);}

            dbg.location(992,96);
            pushFollow(FOLLOW_caseBlock_in_switchStatement5507);
            caseBlock();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 67, switchStatement_StartIndex); }
        }
        dbg.location(993, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "switchStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "switchStatement"


    // $ANTLR start "caseBlock"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:995:1: caseBlock : '{' ( ( LineTerminator )* caseClause )* ( ( LineTerminator )* defaultClause ( ( LineTerminator )* caseClause )* )? ( LineTerminator )* '}' ;
    public final void caseBlock() throws RecognitionException {
        int caseBlock_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "caseBlock");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(995, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 68) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:2: ( '{' ( ( LineTerminator )* caseClause )* ( ( LineTerminator )* defaultClause ( ( LineTerminator )* caseClause )* )? ( LineTerminator )* '}' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:4: '{' ( ( LineTerminator )* caseClause )* ( ( LineTerminator )* defaultClause ( ( LineTerminator )* caseClause )* )? ( LineTerminator )* '}'
            {
            dbg.location(996,4);
            match(input,41,FOLLOW_41_in_caseBlock5519); if (state.failed) return ;
            dbg.location(996,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:8: ( ( LineTerminator )* caseClause )*
            try { dbg.enterSubRule(206);

            loop206:
            do {
                int alt206=2;
                try { dbg.enterDecision(206);

                try {
                    isCyclicDecision = true;
                    alt206 = dfa206.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(206);}

                switch (alt206) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:9: ( LineTerminator )* caseClause
            	    {
            	    dbg.location(996,9);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:9: ( LineTerminator )*
            	    try { dbg.enterSubRule(205);

            	    loop205:
            	    do {
            	        int alt205=2;
            	        try { dbg.enterDecision(205);

            	        int LA205_0 = input.LA(1);

            	        if ( (LA205_0==LineTerminator) ) {
            	            alt205=1;
            	        }


            	        } finally {dbg.exitDecision(205);}

            	        switch (alt205) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(996,9);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_caseBlock5522); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop205;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(205);}

            	    dbg.location(996,25);
            	    pushFollow(FOLLOW_caseClause_in_caseBlock5525);
            	    caseClause();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop206;
                }
            } while (true);
            } finally {dbg.exitSubRule(206);}

            dbg.location(996,38);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:38: ( ( LineTerminator )* defaultClause ( ( LineTerminator )* caseClause )* )?
            int alt210=2;
            try { dbg.enterSubRule(210);
            try { dbg.enterDecision(210);

            try {
                isCyclicDecision = true;
                alt210 = dfa210.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(210);}

            switch (alt210) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:39: ( LineTerminator )* defaultClause ( ( LineTerminator )* caseClause )*
                    {
                    dbg.location(996,39);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:39: ( LineTerminator )*
                    try { dbg.enterSubRule(207);

                    loop207:
                    do {
                        int alt207=2;
                        try { dbg.enterDecision(207);

                        int LA207_0 = input.LA(1);

                        if ( (LA207_0==LineTerminator) ) {
                            alt207=1;
                        }


                        } finally {dbg.exitDecision(207);}

                        switch (alt207) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(996,39);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_caseBlock5530); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop207;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(207);}

                    dbg.location(996,55);
                    pushFollow(FOLLOW_defaultClause_in_caseBlock5533);
                    defaultClause();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(996,69);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:69: ( ( LineTerminator )* caseClause )*
                    try { dbg.enterSubRule(209);

                    loop209:
                    do {
                        int alt209=2;
                        try { dbg.enterDecision(209);

                        try {
                            isCyclicDecision = true;
                            alt209 = dfa209.predict(input);
                        }
                        catch (NoViableAltException nvae) {
                            dbg.recognitionException(nvae);
                            throw nvae;
                        }
                        } finally {dbg.exitDecision(209);}

                        switch (alt209) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:70: ( LineTerminator )* caseClause
                    	    {
                    	    dbg.location(996,70);
                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:70: ( LineTerminator )*
                    	    try { dbg.enterSubRule(208);

                    	    loop208:
                    	    do {
                    	        int alt208=2;
                    	        try { dbg.enterDecision(208);

                    	        int LA208_0 = input.LA(1);

                    	        if ( (LA208_0==LineTerminator) ) {
                    	            alt208=1;
                    	        }


                    	        } finally {dbg.exitDecision(208);}

                    	        switch (alt208) {
                    	    	case 1 :
                    	    	    dbg.enterAlt(1);

                    	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    	    {
                    	    	    dbg.location(996,70);
                    	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_caseBlock5536); if (state.failed) return ;

                    	    	    }
                    	    	    break;

                    	    	default :
                    	    	    break loop208;
                    	        }
                    	    } while (true);
                    	    } finally {dbg.exitSubRule(208);}

                    	    dbg.location(996,86);
                    	    pushFollow(FOLLOW_caseClause_in_caseBlock5539);
                    	    caseClause();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop209;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(209);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(210);}

            dbg.location(996,101);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:996:101: ( LineTerminator )*
            try { dbg.enterSubRule(211);

            loop211:
            do {
                int alt211=2;
                try { dbg.enterDecision(211);

                int LA211_0 = input.LA(1);

                if ( (LA211_0==LineTerminator) ) {
                    alt211=1;
                }


                } finally {dbg.exitDecision(211);}

                switch (alt211) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(996,101);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_caseBlock5545); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop211;
                }
            } while (true);
            } finally {dbg.exitSubRule(211);}

            dbg.location(996,117);
            match(input,42,FOLLOW_42_in_caseBlock5548); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 68, caseBlock_StartIndex); }
        }
        dbg.location(997, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "caseBlock");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "caseBlock"


    // $ANTLR start "caseClause"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:999:1: caseClause : 'case' ( LineTerminator )* expression ( LineTerminator )* ':' ( LineTerminator )* ( statementList )? ;
    public final void caseClause() throws RecognitionException {
        int caseClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "caseClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(999, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 69) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:2: ( 'case' ( LineTerminator )* expression ( LineTerminator )* ':' ( LineTerminator )* ( statementList )? )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:4: 'case' ( LineTerminator )* expression ( LineTerminator )* ':' ( LineTerminator )* ( statementList )?
            {
            dbg.location(1000,4);
            match(input,105,FOLLOW_105_in_caseClause5559); if (state.failed) return ;
            dbg.location(1000,11);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:11: ( LineTerminator )*
            try { dbg.enterSubRule(212);

            loop212:
            do {
                int alt212=2;
                try { dbg.enterDecision(212);

                int LA212_0 = input.LA(1);

                if ( (LA212_0==LineTerminator) ) {
                    alt212=1;
                }


                } finally {dbg.exitDecision(212);}

                switch (alt212) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1000,11);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_caseClause5561); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop212;
                }
            } while (true);
            } finally {dbg.exitSubRule(212);}

            dbg.location(1000,27);
            pushFollow(FOLLOW_expression_in_caseClause5564);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1000,38);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:38: ( LineTerminator )*
            try { dbg.enterSubRule(213);

            loop213:
            do {
                int alt213=2;
                try { dbg.enterDecision(213);

                int LA213_0 = input.LA(1);

                if ( (LA213_0==LineTerminator) ) {
                    alt213=1;
                }


                } finally {dbg.exitDecision(213);}

                switch (alt213) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1000,38);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_caseClause5566); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop213;
                }
            } while (true);
            } finally {dbg.exitSubRule(213);}

            dbg.location(1000,54);
            match(input,43,FOLLOW_43_in_caseClause5569); if (state.failed) return ;
            dbg.location(1000,58);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:58: ( LineTerminator )*
            try { dbg.enterSubRule(214);

            loop214:
            do {
                int alt214=2;
                try { dbg.enterDecision(214);

                int LA214_0 = input.LA(1);

                if ( (LA214_0==LineTerminator) ) {
                    int LA214_1 = input.LA(2);

                    if ( (synpred290_AS3()) ) {
                        alt214=1;
                    }


                }


                } finally {dbg.exitDecision(214);}

                switch (alt214) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1000,58);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_caseClause5571); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop214;
                }
            } while (true);
            } finally {dbg.exitSubRule(214);}

            dbg.location(1000,74);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:74: ( statementList )?
            int alt215=2;
            try { dbg.enterSubRule(215);
            try { dbg.enterDecision(215);

            switch ( input.LA(1) ) {
                case LineTerminator:
                    {
                    int LA215_1 = input.LA(2);

                    if ( (synpred291_AS3()) ) {
                        alt215=1;
                    }
                    }
                    break;
                case Identifier:
                case NullLiteral:
                case BooleanLiteral:
                case NumericLiteral:
                case StringLiteral:
                case 34:
                case 35:
                case 36:
                case 38:
                case 41:
                case 44:
                case 47:
                case 48:
                case 49:
                case 50:
                case 51:
                case 52:
                case 53:
                case 54:
                case 55:
                case 56:
                case 92:
                case 93:
                case 94:
                case 95:
                case 97:
                case 98:
                case 99:
                case 100:
                case 101:
                case 102:
                case 103:
                case 104:
                case 107:
                case 108:
                case 111:
                case 116:
                case 127:
                case 129:
                    {
                    alt215=1;
                    }
                    break;
                case 106:
                    {
                    int LA215_3 = input.LA(2);

                    if ( (synpred291_AS3()) ) {
                        alt215=1;
                    }
                    }
                    break;
                case 42:
                    {
                    int LA215_4 = input.LA(2);

                    if ( (synpred291_AS3()) ) {
                        alt215=1;
                    }
                    }
                    break;
                case 105:
                    {
                    int LA215_5 = input.LA(2);

                    if ( (synpred291_AS3()) ) {
                        alt215=1;
                    }
                    }
                    break;
                case EOF:
                    {
                    int LA215_6 = input.LA(2);

                    if ( (synpred291_AS3()) ) {
                        alt215=1;
                    }
                    }
                    break;
            }

            } finally {dbg.exitDecision(215);}

            switch (alt215) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: statementList
                    {
                    dbg.location(1000,74);
                    pushFollow(FOLLOW_statementList_in_caseClause5574);
                    statementList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(215);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 69, caseClause_StartIndex); }
        }
        dbg.location(1001, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "caseClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "caseClause"


    // $ANTLR start "defaultClause"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1003:1: defaultClause : 'default' ( LineTerminator )* ':' ( LineTerminator )* ( statementList )? ;
    public final void defaultClause() throws RecognitionException {
        int defaultClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "defaultClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1003, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 70) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:2: ( 'default' ( LineTerminator )* ':' ( LineTerminator )* ( statementList )? )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:4: 'default' ( LineTerminator )* ':' ( LineTerminator )* ( statementList )?
            {
            dbg.location(1004,4);
            match(input,106,FOLLOW_106_in_defaultClause5587); if (state.failed) return ;
            dbg.location(1004,14);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:14: ( LineTerminator )*
            try { dbg.enterSubRule(216);

            loop216:
            do {
                int alt216=2;
                try { dbg.enterDecision(216);

                int LA216_0 = input.LA(1);

                if ( (LA216_0==LineTerminator) ) {
                    alt216=1;
                }


                } finally {dbg.exitDecision(216);}

                switch (alt216) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1004,14);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_defaultClause5589); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop216;
                }
            } while (true);
            } finally {dbg.exitSubRule(216);}

            dbg.location(1004,30);
            match(input,43,FOLLOW_43_in_defaultClause5592); if (state.failed) return ;
            dbg.location(1004,34);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:34: ( LineTerminator )*
            try { dbg.enterSubRule(217);

            loop217:
            do {
                int alt217=2;
                try { dbg.enterDecision(217);

                int LA217_0 = input.LA(1);

                if ( (LA217_0==LineTerminator) ) {
                    int LA217_1 = input.LA(2);

                    if ( (synpred293_AS3()) ) {
                        alt217=1;
                    }


                }


                } finally {dbg.exitDecision(217);}

                switch (alt217) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1004,34);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_defaultClause5594); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop217;
                }
            } while (true);
            } finally {dbg.exitSubRule(217);}

            dbg.location(1004,50);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:50: ( statementList )?
            int alt218=2;
            try { dbg.enterSubRule(218);
            try { dbg.enterDecision(218);

            switch ( input.LA(1) ) {
                case LineTerminator:
                    {
                    int LA218_1 = input.LA(2);

                    if ( (synpred294_AS3()) ) {
                        alt218=1;
                    }
                    }
                    break;
                case Identifier:
                case NullLiteral:
                case BooleanLiteral:
                case NumericLiteral:
                case StringLiteral:
                case 34:
                case 35:
                case 36:
                case 38:
                case 41:
                case 44:
                case 47:
                case 48:
                case 49:
                case 50:
                case 51:
                case 52:
                case 53:
                case 54:
                case 55:
                case 56:
                case 92:
                case 93:
                case 94:
                case 95:
                case 97:
                case 98:
                case 99:
                case 100:
                case 101:
                case 102:
                case 103:
                case 104:
                case 107:
                case 108:
                case 111:
                case 116:
                case 127:
                case 129:
                    {
                    alt218=1;
                    }
                    break;
                case 105:
                    {
                    int LA218_3 = input.LA(2);

                    if ( (synpred294_AS3()) ) {
                        alt218=1;
                    }
                    }
                    break;
                case 42:
                    {
                    int LA218_4 = input.LA(2);

                    if ( (synpred294_AS3()) ) {
                        alt218=1;
                    }
                    }
                    break;
                case EOF:
                    {
                    int LA218_5 = input.LA(2);

                    if ( (synpred294_AS3()) ) {
                        alt218=1;
                    }
                    }
                    break;
            }

            } finally {dbg.exitDecision(218);}

            switch (alt218) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: statementList
                    {
                    dbg.location(1004,50);
                    pushFollow(FOLLOW_statementList_in_defaultClause5597);
                    statementList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(218);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 70, defaultClause_StartIndex); }
        }
        dbg.location(1005, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "defaultClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "defaultClause"


    // $ANTLR start "labelledStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1007:1: labelledStatement : Identifier ( LineTerminator )* ':' ( LineTerminator )* statement ;
    public final void labelledStatement() throws RecognitionException {
        int labelledStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "labelledStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1007, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 71) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1008:2: ( Identifier ( LineTerminator )* ':' ( LineTerminator )* statement )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1008:4: Identifier ( LineTerminator )* ':' ( LineTerminator )* statement
            {
            dbg.location(1008,4);
            match(input,Identifier,FOLLOW_Identifier_in_labelledStatement5610); if (state.failed) return ;
            dbg.location(1008,15);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1008:15: ( LineTerminator )*
            try { dbg.enterSubRule(219);

            loop219:
            do {
                int alt219=2;
                try { dbg.enterDecision(219);

                int LA219_0 = input.LA(1);

                if ( (LA219_0==LineTerminator) ) {
                    alt219=1;
                }


                } finally {dbg.exitDecision(219);}

                switch (alt219) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1008,15);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_labelledStatement5612); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop219;
                }
            } while (true);
            } finally {dbg.exitSubRule(219);}

            dbg.location(1008,31);
            match(input,43,FOLLOW_43_in_labelledStatement5615); if (state.failed) return ;
            dbg.location(1008,35);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1008:35: ( LineTerminator )*
            try { dbg.enterSubRule(220);

            loop220:
            do {
                int alt220=2;
                try { dbg.enterDecision(220);

                int LA220_0 = input.LA(1);

                if ( (LA220_0==LineTerminator) ) {
                    alt220=1;
                }


                } finally {dbg.exitDecision(220);}

                switch (alt220) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1008,35);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_labelledStatement5617); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop220;
                }
            } while (true);
            } finally {dbg.exitSubRule(220);}

            dbg.location(1008,51);
            pushFollow(FOLLOW_statement_in_labelledStatement5620);
            statement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 71, labelledStatement_StartIndex); }
        }
        dbg.location(1009, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "labelledStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "labelledStatement"


    // $ANTLR start "throwStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1011:1: throwStatement : 'throw' expression ( ( LineTerminator )* | ';' ) ;
    public final void throwStatement() throws RecognitionException {
        int throwStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "throwStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1011, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 72) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:2: ( 'throw' expression ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:4: 'throw' expression ( ( LineTerminator )* | ';' )
            {
            dbg.location(1012,4);
            match(input,107,FOLLOW_107_in_throwStatement5632); if (state.failed) return ;
            dbg.location(1012,12);
            pushFollow(FOLLOW_expression_in_throwStatement5634);
            expression();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1012,23);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:23: ( ( LineTerminator )* | ';' )
            int alt222=2;
            try { dbg.enterSubRule(222);
            try { dbg.enterDecision(222);

            int LA222_0 = input.LA(1);

            if ( (LA222_0==EOF||LA222_0==LineTerminator||LA222_0==Identifier||(LA222_0>=NullLiteral && LA222_0<=StringLiteral)||(LA222_0>=34 && LA222_0<=36)||LA222_0==38||(LA222_0>=41 && LA222_0<=42)||LA222_0==44||(LA222_0>=47 && LA222_0<=56)||(LA222_0>=92 && LA222_0<=93)||(LA222_0>=95 && LA222_0<=108)||LA222_0==111||LA222_0==116||(LA222_0>=118 && LA222_0<=120)||(LA222_0>=125 && LA222_0<=127)||(LA222_0>=129 && LA222_0<=131)) ) {
                alt222=1;
            }
            else if ( (LA222_0==94) ) {
                int LA222_2 = input.LA(2);

                if ( (synpred298_AS3()) ) {
                    alt222=1;
                }
                else if ( (true) ) {
                    alt222=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 222, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 222, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(222);}

            switch (alt222) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:24: ( LineTerminator )*
                    {
                    dbg.location(1012,24);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:24: ( LineTerminator )*
                    try { dbg.enterSubRule(221);

                    loop221:
                    do {
                        int alt221=2;
                        try { dbg.enterDecision(221);

                        int LA221_0 = input.LA(1);

                        if ( (LA221_0==LineTerminator) ) {
                            int LA221_1 = input.LA(2);

                            if ( (synpred297_AS3()) ) {
                                alt221=1;
                            }


                        }


                        } finally {dbg.exitDecision(221);}

                        switch (alt221) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1012,24);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_throwStatement5637); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop221;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(221);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:42: ';'
                    {
                    dbg.location(1012,42);
                    match(input,94,FOLLOW_94_in_throwStatement5642); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(222);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 72, throwStatement_StartIndex); }
        }
        dbg.location(1013, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "throwStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "throwStatement"


    // $ANTLR start "tryStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1015:1: tryStatement : 'try' ( LineTerminator )* blockStatement ( LineTerminator )* ( ( finallyClause ( LineTerminator )* ) | ( ( catchClause ( LineTerminator )* )+ ( finallyClause )? ) ) ;
    public final void tryStatement() throws RecognitionException {
        int tryStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "tryStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1015, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 73) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:2: ( 'try' ( LineTerminator )* blockStatement ( LineTerminator )* ( ( finallyClause ( LineTerminator )* ) | ( ( catchClause ( LineTerminator )* )+ ( finallyClause )? ) ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:4: 'try' ( LineTerminator )* blockStatement ( LineTerminator )* ( ( finallyClause ( LineTerminator )* ) | ( ( catchClause ( LineTerminator )* )+ ( finallyClause )? ) )
            {
            dbg.location(1016,4);
            match(input,108,FOLLOW_108_in_tryStatement5654); if (state.failed) return ;
            dbg.location(1016,10);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:10: ( LineTerminator )*
            try { dbg.enterSubRule(223);

            loop223:
            do {
                int alt223=2;
                try { dbg.enterDecision(223);

                int LA223_0 = input.LA(1);

                if ( (LA223_0==LineTerminator) ) {
                    alt223=1;
                }


                } finally {dbg.exitDecision(223);}

                switch (alt223) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1016,10);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_tryStatement5656); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop223;
                }
            } while (true);
            } finally {dbg.exitSubRule(223);}

            dbg.location(1016,26);
            pushFollow(FOLLOW_blockStatement_in_tryStatement5659);
            blockStatement();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1016,41);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:41: ( LineTerminator )*
            try { dbg.enterSubRule(224);

            loop224:
            do {
                int alt224=2;
                try { dbg.enterDecision(224);

                int LA224_0 = input.LA(1);

                if ( (LA224_0==LineTerminator) ) {
                    alt224=1;
                }


                } finally {dbg.exitDecision(224);}

                switch (alt224) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1016,41);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_tryStatement5661); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop224;
                }
            } while (true);
            } finally {dbg.exitSubRule(224);}

            dbg.location(1016,57);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:57: ( ( finallyClause ( LineTerminator )* ) | ( ( catchClause ( LineTerminator )* )+ ( finallyClause )? ) )
            int alt229=2;
            try { dbg.enterSubRule(229);
            try { dbg.enterDecision(229);

            int LA229_0 = input.LA(1);

            if ( (LA229_0==110) ) {
                alt229=1;
            }
            else if ( (LA229_0==109) ) {
                alt229=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 229, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(229);}

            switch (alt229) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:58: ( finallyClause ( LineTerminator )* )
                    {
                    dbg.location(1016,58);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:58: ( finallyClause ( LineTerminator )* )
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:59: finallyClause ( LineTerminator )*
                    {
                    dbg.location(1016,59);
                    pushFollow(FOLLOW_finallyClause_in_tryStatement5666);
                    finallyClause();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(1016,73);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:73: ( LineTerminator )*
                    try { dbg.enterSubRule(225);

                    loop225:
                    do {
                        int alt225=2;
                        try { dbg.enterDecision(225);

                        int LA225_0 = input.LA(1);

                        if ( (LA225_0==LineTerminator) ) {
                            int LA225_1 = input.LA(2);

                            if ( (synpred301_AS3()) ) {
                                alt225=1;
                            }


                        }


                        } finally {dbg.exitDecision(225);}

                        switch (alt225) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1016,73);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_tryStatement5668); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop225;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(225);}


                    }


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:91: ( ( catchClause ( LineTerminator )* )+ ( finallyClause )? )
                    {
                    dbg.location(1016,91);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:91: ( ( catchClause ( LineTerminator )* )+ ( finallyClause )? )
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:92: ( catchClause ( LineTerminator )* )+ ( finallyClause )?
                    {
                    dbg.location(1016,92);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:92: ( catchClause ( LineTerminator )* )+
                    int cnt227=0;
                    try { dbg.enterSubRule(227);

                    loop227:
                    do {
                        int alt227=2;
                        try { dbg.enterDecision(227);

                        int LA227_0 = input.LA(1);

                        if ( (LA227_0==109) ) {
                            alt227=1;
                        }


                        } finally {dbg.exitDecision(227);}

                        switch (alt227) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:93: catchClause ( LineTerminator )*
                    	    {
                    	    dbg.location(1016,93);
                    	    pushFollow(FOLLOW_catchClause_in_tryStatement5675);
                    	    catchClause();

                    	    state._fsp--;
                    	    if (state.failed) return ;
                    	    dbg.location(1016,105);
                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:105: ( LineTerminator )*
                    	    try { dbg.enterSubRule(226);

                    	    loop226:
                    	    do {
                    	        int alt226=2;
                    	        try { dbg.enterDecision(226);

                    	        int LA226_0 = input.LA(1);

                    	        if ( (LA226_0==LineTerminator) ) {
                    	            int LA226_2 = input.LA(2);

                    	            if ( (synpred303_AS3()) ) {
                    	                alt226=1;
                    	            }


                    	        }


                    	        } finally {dbg.exitDecision(226);}

                    	        switch (alt226) {
                    	    	case 1 :
                    	    	    dbg.enterAlt(1);

                    	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    	    {
                    	    	    dbg.location(1016,105);
                    	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_tryStatement5677); if (state.failed) return ;

                    	    	    }
                    	    	    break;

                    	    	default :
                    	    	    break loop226;
                    	        }
                    	    } while (true);
                    	    } finally {dbg.exitSubRule(226);}


                    	    }
                    	    break;

                    	default :
                    	    if ( cnt227 >= 1 ) break loop227;
                    	    if (state.backtracking>0) {state.failed=true; return ;}
                                EarlyExitException eee =
                                    new EarlyExitException(227, input);
                                dbg.recognitionException(eee);

                                throw eee;
                        }
                        cnt227++;
                    } while (true);
                    } finally {dbg.exitSubRule(227);}

                    dbg.location(1016,123);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:123: ( finallyClause )?
                    int alt228=2;
                    try { dbg.enterSubRule(228);
                    try { dbg.enterDecision(228);

                    int LA228_0 = input.LA(1);

                    if ( (LA228_0==110) ) {
                        alt228=1;
                    }
                    } finally {dbg.exitDecision(228);}

                    switch (alt228) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: finallyClause
                            {
                            dbg.location(1016,123);
                            pushFollow(FOLLOW_finallyClause_in_tryStatement5682);
                            finallyClause();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(228);}


                    }


                    }
                    break;

            }
            } finally {dbg.exitSubRule(229);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 73, tryStatement_StartIndex); }
        }
        dbg.location(1017, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "tryStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "tryStatement"


    // $ANTLR start "catchClause"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1019:1: catchClause : 'catch' ( LineTerminator )* '(' ( LineTerminator )* Identifier ( typeInformation )? ( LineTerminator )* ')' ( LineTerminator )* blockStatement ;
    public final void catchClause() throws RecognitionException {
        int catchClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "catchClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1019, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 74) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1020:2: ( 'catch' ( LineTerminator )* '(' ( LineTerminator )* Identifier ( typeInformation )? ( LineTerminator )* ')' ( LineTerminator )* blockStatement )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1020:4: 'catch' ( LineTerminator )* '(' ( LineTerminator )* Identifier ( typeInformation )? ( LineTerminator )* ')' ( LineTerminator )* blockStatement
            {
            dbg.location(1020,4);
            match(input,109,FOLLOW_109_in_catchClause5703); if (state.failed) return ;
            dbg.location(1020,12);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1020:12: ( LineTerminator )*
            try { dbg.enterSubRule(230);

            loop230:
            do {
                int alt230=2;
                try { dbg.enterDecision(230);

                int LA230_0 = input.LA(1);

                if ( (LA230_0==LineTerminator) ) {
                    alt230=1;
                }


                } finally {dbg.exitDecision(230);}

                switch (alt230) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1020,12);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_catchClause5705); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop230;
                }
            } while (true);
            } finally {dbg.exitSubRule(230);}

            dbg.location(1020,28);
            match(input,36,FOLLOW_36_in_catchClause5708); if (state.failed) return ;
            dbg.location(1020,32);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1020:32: ( LineTerminator )*
            try { dbg.enterSubRule(231);

            loop231:
            do {
                int alt231=2;
                try { dbg.enterDecision(231);

                int LA231_0 = input.LA(1);

                if ( (LA231_0==LineTerminator) ) {
                    alt231=1;
                }


                } finally {dbg.exitDecision(231);}

                switch (alt231) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1020,32);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_catchClause5710); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop231;
                }
            } while (true);
            } finally {dbg.exitSubRule(231);}

            dbg.location(1020,48);
            match(input,Identifier,FOLLOW_Identifier_in_catchClause5713); if (state.failed) return ;
            dbg.location(1020,59);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1020:59: ( typeInformation )?
            int alt232=2;
            try { dbg.enterSubRule(232);
            try { dbg.enterDecision(232);

            int LA232_0 = input.LA(1);

            if ( (LA232_0==43) ) {
                alt232=1;
            }
            } finally {dbg.exitDecision(232);}

            switch (alt232) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: typeInformation
                    {
                    dbg.location(1020,59);
                    pushFollow(FOLLOW_typeInformation_in_catchClause5715);
                    typeInformation();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(232);}

            dbg.location(1020,76);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1020:76: ( LineTerminator )*
            try { dbg.enterSubRule(233);

            loop233:
            do {
                int alt233=2;
                try { dbg.enterDecision(233);

                int LA233_0 = input.LA(1);

                if ( (LA233_0==LineTerminator) ) {
                    alt233=1;
                }


                } finally {dbg.exitDecision(233);}

                switch (alt233) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1020,76);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_catchClause5718); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop233;
                }
            } while (true);
            } finally {dbg.exitSubRule(233);}

            dbg.location(1020,92);
            match(input,37,FOLLOW_37_in_catchClause5721); if (state.failed) return ;
            dbg.location(1020,96);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1020:96: ( LineTerminator )*
            try { dbg.enterSubRule(234);

            loop234:
            do {
                int alt234=2;
                try { dbg.enterDecision(234);

                int LA234_0 = input.LA(1);

                if ( (LA234_0==LineTerminator) ) {
                    alt234=1;
                }


                } finally {dbg.exitDecision(234);}

                switch (alt234) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1020,96);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_catchClause5723); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop234;
                }
            } while (true);
            } finally {dbg.exitSubRule(234);}

            dbg.location(1020,112);
            pushFollow(FOLLOW_blockStatement_in_catchClause5726);
            blockStatement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 74, catchClause_StartIndex); }
        }
        dbg.location(1021, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "catchClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "catchClause"


    // $ANTLR start "finallyClause"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1023:1: finallyClause : 'finally' ( LineTerminator )* blockStatement ;
    public final void finallyClause() throws RecognitionException {
        int finallyClause_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "finallyClause");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1023, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 75) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1024:2: ( 'finally' ( LineTerminator )* blockStatement )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1024:4: 'finally' ( LineTerminator )* blockStatement
            {
            dbg.location(1024,4);
            match(input,110,FOLLOW_110_in_finallyClause5738); if (state.failed) return ;
            dbg.location(1024,14);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1024:14: ( LineTerminator )*
            try { dbg.enterSubRule(235);

            loop235:
            do {
                int alt235=2;
                try { dbg.enterDecision(235);

                int LA235_0 = input.LA(1);

                if ( (LA235_0==LineTerminator) ) {
                    alt235=1;
                }


                } finally {dbg.exitDecision(235);}

                switch (alt235) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1024,14);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_finallyClause5740); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop235;
                }
            } while (true);
            } finally {dbg.exitSubRule(235);}

            dbg.location(1024,30);
            pushFollow(FOLLOW_blockStatement_in_finallyClause5743);
            blockStatement();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 75, finallyClause_StartIndex); }
        }
        dbg.location(1025, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "finallyClause");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "finallyClause"


    // $ANTLR start "functionDeclaration"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1031:1: functionDeclaration : 'function' ( 'get' | 'set' )? ( LineTerminator )* Identifier ( LineTerminator )* formalParameterList ( LineTerminator )* ( typeInformation )? ( LineTerminator )* '{' ( LineTerminator )* sourceElements ( LineTerminator )* '}' ;
    public final void functionDeclaration() throws RecognitionException {
        int functionDeclaration_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "functionDeclaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1031, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 76) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:2: ( 'function' ( 'get' | 'set' )? ( LineTerminator )* Identifier ( LineTerminator )* formalParameterList ( LineTerminator )* ( typeInformation )? ( LineTerminator )* '{' ( LineTerminator )* sourceElements ( LineTerminator )* '}' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:4: 'function' ( 'get' | 'set' )? ( LineTerminator )* Identifier ( LineTerminator )* formalParameterList ( LineTerminator )* ( typeInformation )? ( LineTerminator )* '{' ( LineTerminator )* sourceElements ( LineTerminator )* '}'
            {
            dbg.location(1032,4);
            match(input,111,FOLLOW_111_in_functionDeclaration5758); if (state.failed) return ;
            dbg.location(1032,15);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:15: ( 'get' | 'set' )?
            int alt236=2;
            try { dbg.enterSubRule(236);
            try { dbg.enterDecision(236);

            int LA236_0 = input.LA(1);

            if ( ((LA236_0>=112 && LA236_0<=113)) ) {
                alt236=1;
            }
            } finally {dbg.exitDecision(236);}

            switch (alt236) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:
                    {
                    dbg.location(1032,15);
                    if ( (input.LA(1)>=112 && input.LA(1)<=113) ) {
                        input.consume();
                        state.errorRecovery=false;state.failed=false;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        MismatchedSetException mse = new MismatchedSetException(null,input);
                        dbg.recognitionException(mse);
                        throw mse;
                    }


                    }
                    break;

            }
            } finally {dbg.exitSubRule(236);}

            dbg.location(1032,30);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:30: ( LineTerminator )*
            try { dbg.enterSubRule(237);

            loop237:
            do {
                int alt237=2;
                try { dbg.enterDecision(237);

                int LA237_0 = input.LA(1);

                if ( (LA237_0==LineTerminator) ) {
                    alt237=1;
                }


                } finally {dbg.exitDecision(237);}

                switch (alt237) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1032,30);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionDeclaration5767); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop237;
                }
            } while (true);
            } finally {dbg.exitSubRule(237);}

            dbg.location(1032,46);
            match(input,Identifier,FOLLOW_Identifier_in_functionDeclaration5770); if (state.failed) return ;
            dbg.location(1032,57);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:57: ( LineTerminator )*
            try { dbg.enterSubRule(238);

            loop238:
            do {
                int alt238=2;
                try { dbg.enterDecision(238);

                int LA238_0 = input.LA(1);

                if ( (LA238_0==LineTerminator) ) {
                    alt238=1;
                }


                } finally {dbg.exitDecision(238);}

                switch (alt238) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1032,57);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionDeclaration5772); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop238;
                }
            } while (true);
            } finally {dbg.exitSubRule(238);}

            dbg.location(1032,73);
            pushFollow(FOLLOW_formalParameterList_in_functionDeclaration5775);
            formalParameterList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1032,93);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:93: ( LineTerminator )*
            try { dbg.enterSubRule(239);

            loop239:
            do {
                int alt239=2;
                try { dbg.enterDecision(239);

                int LA239_0 = input.LA(1);

                if ( (LA239_0==LineTerminator) ) {
                    int LA239_2 = input.LA(2);

                    if ( (synpred316_AS3()) ) {
                        alt239=1;
                    }


                }


                } finally {dbg.exitDecision(239);}

                switch (alt239) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1032,93);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionDeclaration5777); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop239;
                }
            } while (true);
            } finally {dbg.exitSubRule(239);}

            dbg.location(1032,109);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:109: ( typeInformation )?
            int alt240=2;
            try { dbg.enterSubRule(240);
            try { dbg.enterDecision(240);

            int LA240_0 = input.LA(1);

            if ( (LA240_0==43) ) {
                alt240=1;
            }
            } finally {dbg.exitDecision(240);}

            switch (alt240) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: typeInformation
                    {
                    dbg.location(1032,109);
                    pushFollow(FOLLOW_typeInformation_in_functionDeclaration5780);
                    typeInformation();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(240);}

            dbg.location(1032,126);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:126: ( LineTerminator )*
            try { dbg.enterSubRule(241);

            loop241:
            do {
                int alt241=2;
                try { dbg.enterDecision(241);

                int LA241_0 = input.LA(1);

                if ( (LA241_0==LineTerminator) ) {
                    alt241=1;
                }


                } finally {dbg.exitDecision(241);}

                switch (alt241) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1032,126);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionDeclaration5783); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop241;
                }
            } while (true);
            } finally {dbg.exitSubRule(241);}

            dbg.location(1032,142);
            match(input,41,FOLLOW_41_in_functionDeclaration5786); if (state.failed) return ;
            dbg.location(1032,146);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:146: ( LineTerminator )*
            try { dbg.enterSubRule(242);

            loop242:
            do {
                int alt242=2;
                try { dbg.enterDecision(242);

                int LA242_0 = input.LA(1);

                if ( (LA242_0==LineTerminator) ) {
                    int LA242_1 = input.LA(2);

                    if ( (synpred319_AS3()) ) {
                        alt242=1;
                    }


                }


                } finally {dbg.exitDecision(242);}

                switch (alt242) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1032,146);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionDeclaration5788); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop242;
                }
            } while (true);
            } finally {dbg.exitSubRule(242);}

            dbg.location(1032,162);
            pushFollow(FOLLOW_sourceElements_in_functionDeclaration5791);
            sourceElements();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1032,177);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:177: ( LineTerminator )*
            try { dbg.enterSubRule(243);

            loop243:
            do {
                int alt243=2;
                try { dbg.enterDecision(243);

                int LA243_0 = input.LA(1);

                if ( (LA243_0==LineTerminator) ) {
                    alt243=1;
                }


                } finally {dbg.exitDecision(243);}

                switch (alt243) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1032,177);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionDeclaration5793); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop243;
                }
            } while (true);
            } finally {dbg.exitSubRule(243);}

            dbg.location(1032,193);
            match(input,42,FOLLOW_42_in_functionDeclaration5796); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 76, functionDeclaration_StartIndex); }
        }
        dbg.location(1033, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "functionDeclaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "functionDeclaration"


    // $ANTLR start "functionExpression"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1035:1: functionExpression : 'function' ( LineTerminator )* ( Identifier )? ( LineTerminator )* formalParameterList ( LineTerminator )* ( typeInformation )? ( LineTerminator )* '{' ( LineTerminator )* sourceElements ( LineTerminator )* '}' ;
    public final void functionExpression() throws RecognitionException {
        int functionExpression_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "functionExpression");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1035, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 77) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:2: ( 'function' ( LineTerminator )* ( Identifier )? ( LineTerminator )* formalParameterList ( LineTerminator )* ( typeInformation )? ( LineTerminator )* '{' ( LineTerminator )* sourceElements ( LineTerminator )* '}' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:4: 'function' ( LineTerminator )* ( Identifier )? ( LineTerminator )* formalParameterList ( LineTerminator )* ( typeInformation )? ( LineTerminator )* '{' ( LineTerminator )* sourceElements ( LineTerminator )* '}'
            {
            dbg.location(1036,4);
            match(input,111,FOLLOW_111_in_functionExpression5808); if (state.failed) return ;
            dbg.location(1036,15);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:15: ( LineTerminator )*
            try { dbg.enterSubRule(244);

            loop244:
            do {
                int alt244=2;
                try { dbg.enterDecision(244);

                int LA244_0 = input.LA(1);

                if ( (LA244_0==LineTerminator) ) {
                    int LA244_2 = input.LA(2);

                    if ( (synpred321_AS3()) ) {
                        alt244=1;
                    }


                }


                } finally {dbg.exitDecision(244);}

                switch (alt244) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1036,15);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionExpression5810); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop244;
                }
            } while (true);
            } finally {dbg.exitSubRule(244);}

            dbg.location(1036,31);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:31: ( Identifier )?
            int alt245=2;
            try { dbg.enterSubRule(245);
            try { dbg.enterDecision(245);

            int LA245_0 = input.LA(1);

            if ( (LA245_0==Identifier) ) {
                alt245=1;
            }
            } finally {dbg.exitDecision(245);}

            switch (alt245) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: Identifier
                    {
                    dbg.location(1036,31);
                    match(input,Identifier,FOLLOW_Identifier_in_functionExpression5813); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(245);}

            dbg.location(1036,43);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:43: ( LineTerminator )*
            try { dbg.enterSubRule(246);

            loop246:
            do {
                int alt246=2;
                try { dbg.enterDecision(246);

                int LA246_0 = input.LA(1);

                if ( (LA246_0==LineTerminator) ) {
                    alt246=1;
                }


                } finally {dbg.exitDecision(246);}

                switch (alt246) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1036,43);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionExpression5816); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop246;
                }
            } while (true);
            } finally {dbg.exitSubRule(246);}

            dbg.location(1036,59);
            pushFollow(FOLLOW_formalParameterList_in_functionExpression5819);
            formalParameterList();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1036,79);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:79: ( LineTerminator )*
            try { dbg.enterSubRule(247);

            loop247:
            do {
                int alt247=2;
                try { dbg.enterDecision(247);

                int LA247_0 = input.LA(1);

                if ( (LA247_0==LineTerminator) ) {
                    int LA247_2 = input.LA(2);

                    if ( (synpred324_AS3()) ) {
                        alt247=1;
                    }


                }


                } finally {dbg.exitDecision(247);}

                switch (alt247) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1036,79);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionExpression5821); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop247;
                }
            } while (true);
            } finally {dbg.exitSubRule(247);}

            dbg.location(1036,95);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:95: ( typeInformation )?
            int alt248=2;
            try { dbg.enterSubRule(248);
            try { dbg.enterDecision(248);

            int LA248_0 = input.LA(1);

            if ( (LA248_0==43) ) {
                alt248=1;
            }
            } finally {dbg.exitDecision(248);}

            switch (alt248) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: typeInformation
                    {
                    dbg.location(1036,95);
                    pushFollow(FOLLOW_typeInformation_in_functionExpression5824);
                    typeInformation();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(248);}

            dbg.location(1036,112);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:112: ( LineTerminator )*
            try { dbg.enterSubRule(249);

            loop249:
            do {
                int alt249=2;
                try { dbg.enterDecision(249);

                int LA249_0 = input.LA(1);

                if ( (LA249_0==LineTerminator) ) {
                    alt249=1;
                }


                } finally {dbg.exitDecision(249);}

                switch (alt249) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1036,112);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionExpression5827); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop249;
                }
            } while (true);
            } finally {dbg.exitSubRule(249);}

            dbg.location(1036,128);
            match(input,41,FOLLOW_41_in_functionExpression5830); if (state.failed) return ;
            dbg.location(1036,132);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:132: ( LineTerminator )*
            try { dbg.enterSubRule(250);

            loop250:
            do {
                int alt250=2;
                try { dbg.enterDecision(250);

                int LA250_0 = input.LA(1);

                if ( (LA250_0==LineTerminator) ) {
                    int LA250_1 = input.LA(2);

                    if ( (synpred327_AS3()) ) {
                        alt250=1;
                    }


                }


                } finally {dbg.exitDecision(250);}

                switch (alt250) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1036,132);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionExpression5832); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop250;
                }
            } while (true);
            } finally {dbg.exitSubRule(250);}

            dbg.location(1036,148);
            pushFollow(FOLLOW_sourceElements_in_functionExpression5835);
            sourceElements();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1036,163);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:163: ( LineTerminator )*
            try { dbg.enterSubRule(251);

            loop251:
            do {
                int alt251=2;
                try { dbg.enterDecision(251);

                int LA251_0 = input.LA(1);

                if ( (LA251_0==LineTerminator) ) {
                    alt251=1;
                }


                } finally {dbg.exitDecision(251);}

                switch (alt251) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1036,163);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_functionExpression5837); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop251;
                }
            } while (true);
            } finally {dbg.exitSubRule(251);}

            dbg.location(1036,179);
            match(input,42,FOLLOW_42_in_functionExpression5840); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 77, functionExpression_StartIndex); }
        }
        dbg.location(1037, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "functionExpression");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "functionExpression"


    // $ANTLR start "formalParameterList"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1039:1: formalParameterList : '(' ( ( LineTerminator )* formalParameter ( ( LineTerminator )* ',' ( LineTerminator )* formalParameter )* )? ( LineTerminator )* ')' ;
    public final void formalParameterList() throws RecognitionException {
        int formalParameterList_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "formalParameterList");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1039, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 78) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:2: ( '(' ( ( LineTerminator )* formalParameter ( ( LineTerminator )* ',' ( LineTerminator )* formalParameter )* )? ( LineTerminator )* ')' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:4: '(' ( ( LineTerminator )* formalParameter ( ( LineTerminator )* ',' ( LineTerminator )* formalParameter )* )? ( LineTerminator )* ')'
            {
            dbg.location(1040,4);
            match(input,36,FOLLOW_36_in_formalParameterList5851); if (state.failed) return ;
            dbg.location(1040,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:8: ( ( LineTerminator )* formalParameter ( ( LineTerminator )* ',' ( LineTerminator )* formalParameter )* )?
            int alt256=2;
            try { dbg.enterSubRule(256);
            try { dbg.enterDecision(256);

            try {
                isCyclicDecision = true;
                alt256 = dfa256.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(256);}

            switch (alt256) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:9: ( LineTerminator )* formalParameter ( ( LineTerminator )* ',' ( LineTerminator )* formalParameter )*
                    {
                    dbg.location(1040,9);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:9: ( LineTerminator )*
                    try { dbg.enterSubRule(252);

                    loop252:
                    do {
                        int alt252=2;
                        try { dbg.enterDecision(252);

                        int LA252_0 = input.LA(1);

                        if ( (LA252_0==LineTerminator) ) {
                            alt252=1;
                        }


                        } finally {dbg.exitDecision(252);}

                        switch (alt252) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1040,9);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_formalParameterList5854); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop252;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(252);}

                    dbg.location(1040,25);
                    pushFollow(FOLLOW_formalParameter_in_formalParameterList5857);
                    formalParameter();

                    state._fsp--;
                    if (state.failed) return ;
                    dbg.location(1040,41);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:41: ( ( LineTerminator )* ',' ( LineTerminator )* formalParameter )*
                    try { dbg.enterSubRule(255);

                    loop255:
                    do {
                        int alt255=2;
                        try { dbg.enterDecision(255);

                        try {
                            isCyclicDecision = true;
                            alt255 = dfa255.predict(input);
                        }
                        catch (NoViableAltException nvae) {
                            dbg.recognitionException(nvae);
                            throw nvae;
                        }
                        } finally {dbg.exitDecision(255);}

                        switch (alt255) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:42: ( LineTerminator )* ',' ( LineTerminator )* formalParameter
                    	    {
                    	    dbg.location(1040,42);
                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:42: ( LineTerminator )*
                    	    try { dbg.enterSubRule(253);

                    	    loop253:
                    	    do {
                    	        int alt253=2;
                    	        try { dbg.enterDecision(253);

                    	        int LA253_0 = input.LA(1);

                    	        if ( (LA253_0==LineTerminator) ) {
                    	            alt253=1;
                    	        }


                    	        } finally {dbg.exitDecision(253);}

                    	        switch (alt253) {
                    	    	case 1 :
                    	    	    dbg.enterAlt(1);

                    	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    	    {
                    	    	    dbg.location(1040,42);
                    	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_formalParameterList5860); if (state.failed) return ;

                    	    	    }
                    	    	    break;

                    	    	default :
                    	    	    break loop253;
                    	        }
                    	    } while (true);
                    	    } finally {dbg.exitSubRule(253);}

                    	    dbg.location(1040,58);
                    	    match(input,39,FOLLOW_39_in_formalParameterList5863); if (state.failed) return ;
                    	    dbg.location(1040,62);
                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:62: ( LineTerminator )*
                    	    try { dbg.enterSubRule(254);

                    	    loop254:
                    	    do {
                    	        int alt254=2;
                    	        try { dbg.enterDecision(254);

                    	        int LA254_0 = input.LA(1);

                    	        if ( (LA254_0==LineTerminator) ) {
                    	            alt254=1;
                    	        }


                    	        } finally {dbg.exitDecision(254);}

                    	        switch (alt254) {
                    	    	case 1 :
                    	    	    dbg.enterAlt(1);

                    	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    	    {
                    	    	    dbg.location(1040,62);
                    	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_formalParameterList5865); if (state.failed) return ;

                    	    	    }
                    	    	    break;

                    	    	default :
                    	    	    break loop254;
                    	        }
                    	    } while (true);
                    	    } finally {dbg.exitSubRule(254);}

                    	    dbg.location(1040,78);
                    	    pushFollow(FOLLOW_formalParameter_in_formalParameterList5868);
                    	    formalParameter();

                    	    state._fsp--;
                    	    if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop255;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(255);}


                    }
                    break;

            }
            } finally {dbg.exitSubRule(256);}

            dbg.location(1040,99);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1040:99: ( LineTerminator )*
            try { dbg.enterSubRule(257);

            loop257:
            do {
                int alt257=2;
                try { dbg.enterDecision(257);

                int LA257_0 = input.LA(1);

                if ( (LA257_0==LineTerminator) ) {
                    alt257=1;
                }


                } finally {dbg.exitDecision(257);}

                switch (alt257) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1040,99);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_formalParameterList5875); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop257;
                }
            } while (true);
            } finally {dbg.exitSubRule(257);}

            dbg.location(1040,115);
            match(input,37,FOLLOW_37_in_formalParameterList5878); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 78, formalParameterList_StartIndex); }
        }
        dbg.location(1041, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "formalParameterList");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "formalParameterList"


    // $ANTLR start "formalParameter"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1043:1: formalParameter : ( Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( defaultArgumentValue )? | '...' ( LineTerminator )* Identifier | Identifier ( LineTerminator )* '...' );
    public final void formalParameter() throws RecognitionException {
        int formalParameter_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "formalParameter");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1043, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 79) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:2: ( Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( defaultArgumentValue )? | '...' ( LineTerminator )* Identifier | Identifier ( LineTerminator )* '...' )
            int alt264=3;
            try { dbg.enterDecision(264);

            try {
                isCyclicDecision = true;
                alt264 = dfa264.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(264);}

            switch (alt264) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:4: Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( defaultArgumentValue )?
                    {
                    dbg.location(1044,4);
                    match(input,Identifier,FOLLOW_Identifier_in_formalParameter5890); if (state.failed) return ;
                    dbg.location(1044,15);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:15: ( LineTerminator )*
                    try { dbg.enterSubRule(258);

                    loop258:
                    do {
                        int alt258=2;
                        try { dbg.enterDecision(258);

                        int LA258_0 = input.LA(1);

                        if ( (LA258_0==LineTerminator) ) {
                            int LA258_2 = input.LA(2);

                            if ( (synpred335_AS3()) ) {
                                alt258=1;
                            }


                        }


                        } finally {dbg.exitDecision(258);}

                        switch (alt258) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1044,15);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_formalParameter5892); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop258;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(258);}

                    dbg.location(1044,31);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:31: ( typeInformation )?
                    int alt259=2;
                    try { dbg.enterSubRule(259);
                    try { dbg.enterDecision(259);

                    int LA259_0 = input.LA(1);

                    if ( (LA259_0==43) ) {
                        alt259=1;
                    }
                    } finally {dbg.exitDecision(259);}

                    switch (alt259) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: typeInformation
                            {
                            dbg.location(1044,31);
                            pushFollow(FOLLOW_typeInformation_in_formalParameter5895);
                            typeInformation();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(259);}

                    dbg.location(1044,48);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:48: ( LineTerminator )*
                    try { dbg.enterSubRule(260);

                    loop260:
                    do {
                        int alt260=2;
                        try { dbg.enterDecision(260);

                        int LA260_0 = input.LA(1);

                        if ( (LA260_0==LineTerminator) ) {
                            int LA260_2 = input.LA(2);

                            if ( (synpred337_AS3()) ) {
                                alt260=1;
                            }


                        }


                        } finally {dbg.exitDecision(260);}

                        switch (alt260) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1044,48);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_formalParameter5898); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop260;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(260);}

                    dbg.location(1044,64);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:64: ( defaultArgumentValue )?
                    int alt261=2;
                    try { dbg.enterSubRule(261);
                    try { dbg.enterDecision(261);

                    int LA261_0 = input.LA(1);

                    if ( (LA261_0==80) ) {
                        alt261=1;
                    }
                    } finally {dbg.exitDecision(261);}

                    switch (alt261) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: defaultArgumentValue
                            {
                            dbg.location(1044,64);
                            pushFollow(FOLLOW_defaultArgumentValue_in_formalParameter5901);
                            defaultArgumentValue();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(261);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1045:4: '...' ( LineTerminator )* Identifier
                    {
                    dbg.location(1045,4);
                    match(input,114,FOLLOW_114_in_formalParameter5907); if (state.failed) return ;
                    dbg.location(1045,10);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1045:10: ( LineTerminator )*
                    try { dbg.enterSubRule(262);

                    loop262:
                    do {
                        int alt262=2;
                        try { dbg.enterDecision(262);

                        int LA262_0 = input.LA(1);

                        if ( (LA262_0==LineTerminator) ) {
                            alt262=1;
                        }


                        } finally {dbg.exitDecision(262);}

                        switch (alt262) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1045,10);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_formalParameter5909); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop262;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(262);}

                    dbg.location(1045,26);
                    match(input,Identifier,FOLLOW_Identifier_in_formalParameter5912); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1046:4: Identifier ( LineTerminator )* '...'
                    {
                    dbg.location(1046,4);
                    match(input,Identifier,FOLLOW_Identifier_in_formalParameter5917); if (state.failed) return ;
                    dbg.location(1046,15);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1046:15: ( LineTerminator )*
                    try { dbg.enterSubRule(263);

                    loop263:
                    do {
                        int alt263=2;
                        try { dbg.enterDecision(263);

                        int LA263_0 = input.LA(1);

                        if ( (LA263_0==LineTerminator) ) {
                            alt263=1;
                        }


                        } finally {dbg.exitDecision(263);}

                        switch (alt263) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1046,15);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_formalParameter5919); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop263;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(263);}

                    dbg.location(1046,31);
                    match(input,114,FOLLOW_114_in_formalParameter5922); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 79, formalParameter_StartIndex); }
        }
        dbg.location(1047, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "formalParameter");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "formalParameter"


    // $ANTLR start "sourceElements"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1049:1: sourceElements : ( ( LineTerminator )* sourceElement ( LineTerminator )* )* ;
    public final void sourceElements() throws RecognitionException {
        int sourceElements_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "sourceElements");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1049, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 80) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1050:2: ( ( ( LineTerminator )* sourceElement ( LineTerminator )* )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1050:4: ( ( LineTerminator )* sourceElement ( LineTerminator )* )*
            {
            dbg.location(1050,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1050:4: ( ( LineTerminator )* sourceElement ( LineTerminator )* )*
            try { dbg.enterSubRule(267);

            loop267:
            do {
                int alt267=2;
                try { dbg.enterDecision(267);

                try {
                    isCyclicDecision = true;
                    alt267 = dfa267.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(267);}

                switch (alt267) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1050:5: ( LineTerminator )* sourceElement ( LineTerminator )*
            	    {
            	    dbg.location(1050,5);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1050:5: ( LineTerminator )*
            	    try { dbg.enterSubRule(265);

            	    loop265:
            	    do {
            	        int alt265=2;
            	        try { dbg.enterDecision(265);

            	        int LA265_0 = input.LA(1);

            	        if ( (LA265_0==LineTerminator) ) {
            	            alt265=1;
            	        }


            	        } finally {dbg.exitDecision(265);}

            	        switch (alt265) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1050,5);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_sourceElements5936); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop265;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(265);}

            	    dbg.location(1050,21);
            	    pushFollow(FOLLOW_sourceElement_in_sourceElements5939);
            	    sourceElement();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(1050,35);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1050:35: ( LineTerminator )*
            	    try { dbg.enterSubRule(266);

            	    loop266:
            	    do {
            	        int alt266=2;
            	        try { dbg.enterDecision(266);

            	        int LA266_0 = input.LA(1);

            	        if ( (LA266_0==LineTerminator) ) {
            	            int LA266_1 = input.LA(2);

            	            if ( (synpred344_AS3()) ) {
            	                alt266=1;
            	            }


            	        }


            	        } finally {dbg.exitDecision(266);}

            	        switch (alt266) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1050,35);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_sourceElements5941); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop266;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(266);}


            	    }
            	    break;

            	default :
            	    break loop267;
                }
            } while (true);
            } finally {dbg.exitSubRule(267);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 80, sourceElements_StartIndex); }
        }
        dbg.location(1051, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "sourceElements");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "sourceElements"


    // $ANTLR start "sourceElement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1053:1: sourceElement : ( functionDeclaration | statement );
    public final void sourceElement() throws RecognitionException {
        int sourceElement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "sourceElement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1053, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 81) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1054:2: ( functionDeclaration | statement )
            int alt268=2;
            try { dbg.enterDecision(268);

            try {
                isCyclicDecision = true;
                alt268 = dfa268.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(268);}

            switch (alt268) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1054:4: functionDeclaration
                    {
                    dbg.location(1054,4);
                    pushFollow(FOLLOW_functionDeclaration_in_sourceElement5955);
                    functionDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1055:4: statement
                    {
                    dbg.location(1055,4);
                    pushFollow(FOLLOW_statement_in_sourceElement5960);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 81, sourceElement_StartIndex); }
        }
        dbg.location(1056, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "sourceElement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "sourceElement"


    // $ANTLR start "packageDeclaration"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1063:1: packageDeclaration : 'package' ( LineTerminator )* ( qualifiedName )? ( LineTerminator )* '{' ( LineTerminator )* packageElements ( LineTerminator )* '}' ;
    public final void packageDeclaration() throws RecognitionException {
        int packageDeclaration_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "packageDeclaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1063, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 82) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:2: ( 'package' ( LineTerminator )* ( qualifiedName )? ( LineTerminator )* '{' ( LineTerminator )* packageElements ( LineTerminator )* '}' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:4: 'package' ( LineTerminator )* ( qualifiedName )? ( LineTerminator )* '{' ( LineTerminator )* packageElements ( LineTerminator )* '}'
            {
            dbg.location(1064,4);
            match(input,115,FOLLOW_115_in_packageDeclaration5976); if (state.failed) return ;
            dbg.location(1064,14);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:14: ( LineTerminator )*
            try { dbg.enterSubRule(269);

            loop269:
            do {
                int alt269=2;
                try { dbg.enterDecision(269);

                int LA269_0 = input.LA(1);

                if ( (LA269_0==LineTerminator) ) {
                    int LA269_2 = input.LA(2);

                    if ( (synpred347_AS3()) ) {
                        alt269=1;
                    }


                }


                } finally {dbg.exitDecision(269);}

                switch (alt269) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1064,14);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_packageDeclaration5978); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop269;
                }
            } while (true);
            } finally {dbg.exitSubRule(269);}

            dbg.location(1064,30);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:30: ( qualifiedName )?
            int alt270=2;
            try { dbg.enterSubRule(270);
            try { dbg.enterDecision(270);

            int LA270_0 = input.LA(1);

            if ( (LA270_0==Identifier) ) {
                alt270=1;
            }
            } finally {dbg.exitDecision(270);}

            switch (alt270) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: qualifiedName
                    {
                    dbg.location(1064,30);
                    pushFollow(FOLLOW_qualifiedName_in_packageDeclaration5981);
                    qualifiedName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(270);}

            dbg.location(1064,45);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:45: ( LineTerminator )*
            try { dbg.enterSubRule(271);

            loop271:
            do {
                int alt271=2;
                try { dbg.enterDecision(271);

                int LA271_0 = input.LA(1);

                if ( (LA271_0==LineTerminator) ) {
                    alt271=1;
                }


                } finally {dbg.exitDecision(271);}

                switch (alt271) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1064,45);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_packageDeclaration5984); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop271;
                }
            } while (true);
            } finally {dbg.exitSubRule(271);}

            dbg.location(1064,61);
            match(input,41,FOLLOW_41_in_packageDeclaration5987); if (state.failed) return ;
            dbg.location(1064,65);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:65: ( LineTerminator )*
            try { dbg.enterSubRule(272);

            loop272:
            do {
                int alt272=2;
                try { dbg.enterDecision(272);

                int LA272_0 = input.LA(1);

                if ( (LA272_0==LineTerminator) ) {
                    int LA272_1 = input.LA(2);

                    if ( (synpred350_AS3()) ) {
                        alt272=1;
                    }


                }


                } finally {dbg.exitDecision(272);}

                switch (alt272) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1064,65);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_packageDeclaration5989); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop272;
                }
            } while (true);
            } finally {dbg.exitSubRule(272);}

            dbg.location(1064,81);
            pushFollow(FOLLOW_packageElements_in_packageDeclaration5992);
            packageElements();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1064,97);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:97: ( LineTerminator )*
            try { dbg.enterSubRule(273);

            loop273:
            do {
                int alt273=2;
                try { dbg.enterDecision(273);

                int LA273_0 = input.LA(1);

                if ( (LA273_0==LineTerminator) ) {
                    alt273=1;
                }


                } finally {dbg.exitDecision(273);}

                switch (alt273) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1064,97);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_packageDeclaration5994); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop273;
                }
            } while (true);
            } finally {dbg.exitSubRule(273);}

            dbg.location(1064,113);
            match(input,42,FOLLOW_42_in_packageDeclaration5997); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 82, packageDeclaration_StartIndex); }
        }
        dbg.location(1065, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "packageDeclaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "packageDeclaration"


    // $ANTLR start "packageElements"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1067:1: packageElements : ( ( LineTerminator )* packageElement ( LineTerminator )* )* ;
    public final void packageElements() throws RecognitionException {
        int packageElements_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "packageElements");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1067, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 83) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:2: ( ( ( LineTerminator )* packageElement ( LineTerminator )* )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:4: ( ( LineTerminator )* packageElement ( LineTerminator )* )*
            {
            dbg.location(1068,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:4: ( ( LineTerminator )* packageElement ( LineTerminator )* )*
            try { dbg.enterSubRule(276);

            loop276:
            do {
                int alt276=2;
                try { dbg.enterDecision(276);

                try {
                    isCyclicDecision = true;
                    alt276 = dfa276.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(276);}

                switch (alt276) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:5: ( LineTerminator )* packageElement ( LineTerminator )*
            	    {
            	    dbg.location(1068,5);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:5: ( LineTerminator )*
            	    try { dbg.enterSubRule(274);

            	    loop274:
            	    do {
            	        int alt274=2;
            	        try { dbg.enterDecision(274);

            	        int LA274_0 = input.LA(1);

            	        if ( (LA274_0==LineTerminator) ) {
            	            int LA274_2 = input.LA(2);

            	            if ( (synpred352_AS3()) ) {
            	                alt274=1;
            	            }


            	        }


            	        } finally {dbg.exitDecision(274);}

            	        switch (alt274) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1068,5);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_packageElements6010); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop274;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(274);}

            	    dbg.location(1068,21);
            	    pushFollow(FOLLOW_packageElement_in_packageElements6013);
            	    packageElement();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(1068,36);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:36: ( LineTerminator )*
            	    try { dbg.enterSubRule(275);

            	    loop275:
            	    do {
            	        int alt275=2;
            	        try { dbg.enterDecision(275);

            	        int LA275_0 = input.LA(1);

            	        if ( (LA275_0==LineTerminator) ) {
            	            int LA275_1 = input.LA(2);

            	            if ( (synpred353_AS3()) ) {
            	                alt275=1;
            	            }


            	        }


            	        } finally {dbg.exitDecision(275);}

            	        switch (alt275) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1068,36);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_packageElements6015); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop275;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(275);}


            	    }
            	    break;

            	default :
            	    break loop276;
                }
            } while (true);
            } finally {dbg.exitSubRule(276);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 83, packageElements_StartIndex); }
        }
        dbg.location(1069, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "packageElements");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "packageElements"


    // $ANTLR start "packageElement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1071:1: packageElement : ( classDeclaration | interfaceDeclaration | statement );
    public final void packageElement() throws RecognitionException {
        int packageElement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "packageElement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1071, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 84) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1072:2: ( classDeclaration | interfaceDeclaration | statement )
            int alt277=3;
            try { dbg.enterDecision(277);

            try {
                isCyclicDecision = true;
                alt277 = dfa277.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(277);}

            switch (alt277) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1072:4: classDeclaration
                    {
                    dbg.location(1072,4);
                    pushFollow(FOLLOW_classDeclaration_in_packageElement6029);
                    classDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1073:4: interfaceDeclaration
                    {
                    dbg.location(1073,4);
                    pushFollow(FOLLOW_interfaceDeclaration_in_packageElement6034);
                    interfaceDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1074:4: statement
                    {
                    dbg.location(1074,4);
                    pushFollow(FOLLOW_statement_in_packageElement6039);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 84, packageElement_StartIndex); }
        }
        dbg.location(1075, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "packageElement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "packageElement"


    // $ANTLR start "importStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1077:1: importStatement : 'import' ( LineTerminator )* qualifiedName ( '.*' )? ( ( LineTerminator )* | ';' ) ;
    public final void importStatement() throws RecognitionException {
        int importStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "importStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1077, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 85) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:2: ( 'import' ( LineTerminator )* qualifiedName ( '.*' )? ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:4: 'import' ( LineTerminator )* qualifiedName ( '.*' )? ( ( LineTerminator )* | ';' )
            {
            dbg.location(1078,4);
            match(input,116,FOLLOW_116_in_importStatement6050); if (state.failed) return ;
            dbg.location(1078,13);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:13: ( LineTerminator )*
            try { dbg.enterSubRule(278);

            loop278:
            do {
                int alt278=2;
                try { dbg.enterDecision(278);

                int LA278_0 = input.LA(1);

                if ( (LA278_0==LineTerminator) ) {
                    alt278=1;
                }


                } finally {dbg.exitDecision(278);}

                switch (alt278) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1078,13);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_importStatement6052); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop278;
                }
            } while (true);
            } finally {dbg.exitSubRule(278);}

            dbg.location(1078,29);
            pushFollow(FOLLOW_qualifiedName_in_importStatement6055);
            qualifiedName();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1078,43);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:43: ( '.*' )?
            int alt279=2;
            try { dbg.enterSubRule(279);
            try { dbg.enterDecision(279);

            int LA279_0 = input.LA(1);

            if ( (LA279_0==117) ) {
                alt279=1;
            }
            } finally {dbg.exitDecision(279);}

            switch (alt279) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: '.*'
                    {
                    dbg.location(1078,43);
                    match(input,117,FOLLOW_117_in_importStatement6057); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(279);}

            dbg.location(1078,49);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:49: ( ( LineTerminator )* | ';' )
            int alt281=2;
            try { dbg.enterSubRule(281);
            try { dbg.enterDecision(281);

            int LA281_0 = input.LA(1);

            if ( (LA281_0==EOF||LA281_0==LineTerminator||LA281_0==Identifier||(LA281_0>=NullLiteral && LA281_0<=StringLiteral)||(LA281_0>=34 && LA281_0<=36)||LA281_0==38||(LA281_0>=41 && LA281_0<=42)||LA281_0==44||(LA281_0>=47 && LA281_0<=56)||(LA281_0>=92 && LA281_0<=93)||(LA281_0>=95 && LA281_0<=108)||LA281_0==111||LA281_0==116||(LA281_0>=118 && LA281_0<=120)||(LA281_0>=125 && LA281_0<=127)||(LA281_0>=129 && LA281_0<=131)) ) {
                alt281=1;
            }
            else if ( (LA281_0==94) ) {
                int LA281_2 = input.LA(2);

                if ( (synpred360_AS3()) ) {
                    alt281=1;
                }
                else if ( (true) ) {
                    alt281=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 281, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 281, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(281);}

            switch (alt281) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:50: ( LineTerminator )*
                    {
                    dbg.location(1078,50);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:50: ( LineTerminator )*
                    try { dbg.enterSubRule(280);

                    loop280:
                    do {
                        int alt280=2;
                        try { dbg.enterDecision(280);

                        int LA280_0 = input.LA(1);

                        if ( (LA280_0==LineTerminator) ) {
                            int LA280_1 = input.LA(2);

                            if ( (synpred359_AS3()) ) {
                                alt280=1;
                            }


                        }


                        } finally {dbg.exitDecision(280);}

                        switch (alt280) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1078,50);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_importStatement6061); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop280;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(280);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:68: ';'
                    {
                    dbg.location(1078,68);
                    match(input,94,FOLLOW_94_in_importStatement6066); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(281);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 85, importStatement_StartIndex); }
        }
        dbg.location(1079, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "importStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "importStatement"


    // $ANTLR start "classDeclaration"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1081:1: classDeclaration : ( 'final' )? ( LineTerminator )* ( 'public' | 'internal' ) ( LineTerminator )* normalClassDeclaration ;
    public final void classDeclaration() throws RecognitionException {
        int classDeclaration_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "classDeclaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1081, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 86) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1082:2: ( ( 'final' )? ( LineTerminator )* ( 'public' | 'internal' ) ( LineTerminator )* normalClassDeclaration )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1082:4: ( 'final' )? ( LineTerminator )* ( 'public' | 'internal' ) ( LineTerminator )* normalClassDeclaration
            {
            dbg.location(1082,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1082:4: ( 'final' )?
            int alt282=2;
            try { dbg.enterSubRule(282);
            try { dbg.enterDecision(282);

            int LA282_0 = input.LA(1);

            if ( (LA282_0==118) ) {
                alt282=1;
            }
            } finally {dbg.exitDecision(282);}

            switch (alt282) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'final'
                    {
                    dbg.location(1082,4);
                    match(input,118,FOLLOW_118_in_classDeclaration6078); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(282);}

            dbg.location(1082,13);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1082:13: ( LineTerminator )*
            try { dbg.enterSubRule(283);

            loop283:
            do {
                int alt283=2;
                try { dbg.enterDecision(283);

                int LA283_0 = input.LA(1);

                if ( (LA283_0==LineTerminator) ) {
                    alt283=1;
                }


                } finally {dbg.exitDecision(283);}

                switch (alt283) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1082,13);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classDeclaration6081); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop283;
                }
            } while (true);
            } finally {dbg.exitSubRule(283);}

            dbg.location(1082,29);
            if ( (input.LA(1)>=119 && input.LA(1)<=120) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }

            dbg.location(1082,53);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1082:53: ( LineTerminator )*
            try { dbg.enterSubRule(284);

            loop284:
            do {
                int alt284=2;
                try { dbg.enterDecision(284);

                int LA284_0 = input.LA(1);

                if ( (LA284_0==LineTerminator) ) {
                    int LA284_2 = input.LA(2);

                    if ( (synpred364_AS3()) ) {
                        alt284=1;
                    }


                }


                } finally {dbg.exitDecision(284);}

                switch (alt284) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1082,53);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classDeclaration6092); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop284;
                }
            } while (true);
            } finally {dbg.exitSubRule(284);}

            dbg.location(1082,69);
            pushFollow(FOLLOW_normalClassDeclaration_in_classDeclaration6095);
            normalClassDeclaration();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 86, classDeclaration_StartIndex); }
        }
        dbg.location(1083, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "classDeclaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "classDeclaration"


    // $ANTLR start "normalClassDeclaration"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1085:1: normalClassDeclaration : ( 'final' )? ( LineTerminator )* 'class' ( LineTerminator )* qualifiedName ( LineTerminator )* ( inheritance )? ( LineTerminator )* ( interfaceImplementations )? ( LineTerminator )* '{' ( LineTerminator )* classElements ( LineTerminator )* '}' ;
    public final void normalClassDeclaration() throws RecognitionException {
        int normalClassDeclaration_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "normalClassDeclaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1085, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 87) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:2: ( ( 'final' )? ( LineTerminator )* 'class' ( LineTerminator )* qualifiedName ( LineTerminator )* ( inheritance )? ( LineTerminator )* ( interfaceImplementations )? ( LineTerminator )* '{' ( LineTerminator )* classElements ( LineTerminator )* '}' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:4: ( 'final' )? ( LineTerminator )* 'class' ( LineTerminator )* qualifiedName ( LineTerminator )* ( inheritance )? ( LineTerminator )* ( interfaceImplementations )? ( LineTerminator )* '{' ( LineTerminator )* classElements ( LineTerminator )* '}'
            {
            dbg.location(1086,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:4: ( 'final' )?
            int alt285=2;
            try { dbg.enterSubRule(285);
            try { dbg.enterDecision(285);

            int LA285_0 = input.LA(1);

            if ( (LA285_0==118) ) {
                alt285=1;
            }
            } finally {dbg.exitDecision(285);}

            switch (alt285) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'final'
                    {
                    dbg.location(1086,4);
                    match(input,118,FOLLOW_118_in_normalClassDeclaration6106); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(285);}

            dbg.location(1086,13);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:13: ( LineTerminator )*
            try { dbg.enterSubRule(286);

            loop286:
            do {
                int alt286=2;
                try { dbg.enterDecision(286);

                int LA286_0 = input.LA(1);

                if ( (LA286_0==LineTerminator) ) {
                    alt286=1;
                }


                } finally {dbg.exitDecision(286);}

                switch (alt286) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1086,13);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalClassDeclaration6109); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop286;
                }
            } while (true);
            } finally {dbg.exitSubRule(286);}

            dbg.location(1086,29);
            match(input,121,FOLLOW_121_in_normalClassDeclaration6112); if (state.failed) return ;
            dbg.location(1086,37);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:37: ( LineTerminator )*
            try { dbg.enterSubRule(287);

            loop287:
            do {
                int alt287=2;
                try { dbg.enterDecision(287);

                int LA287_0 = input.LA(1);

                if ( (LA287_0==LineTerminator) ) {
                    alt287=1;
                }


                } finally {dbg.exitDecision(287);}

                switch (alt287) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1086,37);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalClassDeclaration6114); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop287;
                }
            } while (true);
            } finally {dbg.exitSubRule(287);}

            dbg.location(1086,53);
            pushFollow(FOLLOW_qualifiedName_in_normalClassDeclaration6117);
            qualifiedName();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1086,67);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:67: ( LineTerminator )*
            try { dbg.enterSubRule(288);

            loop288:
            do {
                int alt288=2;
                try { dbg.enterDecision(288);

                int LA288_0 = input.LA(1);

                if ( (LA288_0==LineTerminator) ) {
                    int LA288_2 = input.LA(2);

                    if ( (synpred368_AS3()) ) {
                        alt288=1;
                    }


                }


                } finally {dbg.exitDecision(288);}

                switch (alt288) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1086,67);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalClassDeclaration6119); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop288;
                }
            } while (true);
            } finally {dbg.exitSubRule(288);}

            dbg.location(1086,83);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:83: ( inheritance )?
            int alt289=2;
            try { dbg.enterSubRule(289);
            try { dbg.enterDecision(289);

            int LA289_0 = input.LA(1);

            if ( (LA289_0==123) ) {
                alt289=1;
            }
            } finally {dbg.exitDecision(289);}

            switch (alt289) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: inheritance
                    {
                    dbg.location(1086,83);
                    pushFollow(FOLLOW_inheritance_in_normalClassDeclaration6122);
                    inheritance();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(289);}

            dbg.location(1086,96);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:96: ( LineTerminator )*
            try { dbg.enterSubRule(290);

            loop290:
            do {
                int alt290=2;
                try { dbg.enterDecision(290);

                int LA290_0 = input.LA(1);

                if ( (LA290_0==LineTerminator) ) {
                    int LA290_2 = input.LA(2);

                    if ( (synpred370_AS3()) ) {
                        alt290=1;
                    }


                }


                } finally {dbg.exitDecision(290);}

                switch (alt290) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1086,96);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalClassDeclaration6125); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop290;
                }
            } while (true);
            } finally {dbg.exitSubRule(290);}

            dbg.location(1086,112);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:112: ( interfaceImplementations )?
            int alt291=2;
            try { dbg.enterSubRule(291);
            try { dbg.enterDecision(291);

            int LA291_0 = input.LA(1);

            if ( (LA291_0==124) ) {
                alt291=1;
            }
            } finally {dbg.exitDecision(291);}

            switch (alt291) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: interfaceImplementations
                    {
                    dbg.location(1086,112);
                    pushFollow(FOLLOW_interfaceImplementations_in_normalClassDeclaration6128);
                    interfaceImplementations();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(291);}

            dbg.location(1086,138);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:138: ( LineTerminator )*
            try { dbg.enterSubRule(292);

            loop292:
            do {
                int alt292=2;
                try { dbg.enterDecision(292);

                int LA292_0 = input.LA(1);

                if ( (LA292_0==LineTerminator) ) {
                    alt292=1;
                }


                } finally {dbg.exitDecision(292);}

                switch (alt292) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1086,138);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalClassDeclaration6131); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop292;
                }
            } while (true);
            } finally {dbg.exitSubRule(292);}

            dbg.location(1086,154);
            match(input,41,FOLLOW_41_in_normalClassDeclaration6134); if (state.failed) return ;
            dbg.location(1086,158);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:158: ( LineTerminator )*
            try { dbg.enterSubRule(293);

            loop293:
            do {
                int alt293=2;
                try { dbg.enterDecision(293);

                int LA293_0 = input.LA(1);

                if ( (LA293_0==LineTerminator) ) {
                    int LA293_1 = input.LA(2);

                    if ( (synpred373_AS3()) ) {
                        alt293=1;
                    }


                }


                } finally {dbg.exitDecision(293);}

                switch (alt293) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1086,158);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalClassDeclaration6136); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop293;
                }
            } while (true);
            } finally {dbg.exitSubRule(293);}

            dbg.location(1086,174);
            pushFollow(FOLLOW_classElements_in_normalClassDeclaration6139);
            classElements();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1086,188);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:188: ( LineTerminator )*
            try { dbg.enterSubRule(294);

            loop294:
            do {
                int alt294=2;
                try { dbg.enterDecision(294);

                int LA294_0 = input.LA(1);

                if ( (LA294_0==LineTerminator) ) {
                    alt294=1;
                }


                } finally {dbg.exitDecision(294);}

                switch (alt294) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1086,188);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalClassDeclaration6141); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop294;
                }
            } while (true);
            } finally {dbg.exitSubRule(294);}

            dbg.location(1086,204);
            match(input,42,FOLLOW_42_in_normalClassDeclaration6144); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 87, normalClassDeclaration_StartIndex); }
        }
        dbg.location(1087, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "normalClassDeclaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "normalClassDeclaration"


    // $ANTLR start "interfaceDeclaration"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1089:1: interfaceDeclaration : ( 'final' )? ( LineTerminator )* ( 'public' | 'internal' ) ( LineTerminator )* normalInterfaceDeclaration ;
    public final void interfaceDeclaration() throws RecognitionException {
        int interfaceDeclaration_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "interfaceDeclaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1089, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 88) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1090:2: ( ( 'final' )? ( LineTerminator )* ( 'public' | 'internal' ) ( LineTerminator )* normalInterfaceDeclaration )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1090:4: ( 'final' )? ( LineTerminator )* ( 'public' | 'internal' ) ( LineTerminator )* normalInterfaceDeclaration
            {
            dbg.location(1090,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1090:4: ( 'final' )?
            int alt295=2;
            try { dbg.enterSubRule(295);
            try { dbg.enterDecision(295);

            int LA295_0 = input.LA(1);

            if ( (LA295_0==118) ) {
                alt295=1;
            }
            } finally {dbg.exitDecision(295);}

            switch (alt295) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'final'
                    {
                    dbg.location(1090,4);
                    match(input,118,FOLLOW_118_in_interfaceDeclaration6156); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(295);}

            dbg.location(1090,13);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1090:13: ( LineTerminator )*
            try { dbg.enterSubRule(296);

            loop296:
            do {
                int alt296=2;
                try { dbg.enterDecision(296);

                int LA296_0 = input.LA(1);

                if ( (LA296_0==LineTerminator) ) {
                    alt296=1;
                }


                } finally {dbg.exitDecision(296);}

                switch (alt296) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1090,13);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_interfaceDeclaration6159); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop296;
                }
            } while (true);
            } finally {dbg.exitSubRule(296);}

            dbg.location(1090,29);
            if ( (input.LA(1)>=119 && input.LA(1)<=120) ) {
                input.consume();
                state.errorRecovery=false;state.failed=false;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                MismatchedSetException mse = new MismatchedSetException(null,input);
                dbg.recognitionException(mse);
                throw mse;
            }

            dbg.location(1090,53);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1090:53: ( LineTerminator )*
            try { dbg.enterSubRule(297);

            loop297:
            do {
                int alt297=2;
                try { dbg.enterDecision(297);

                int LA297_0 = input.LA(1);

                if ( (LA297_0==LineTerminator) ) {
                    int LA297_2 = input.LA(2);

                    if ( (synpred378_AS3()) ) {
                        alt297=1;
                    }


                }


                } finally {dbg.exitDecision(297);}

                switch (alt297) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1090,53);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_interfaceDeclaration6170); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop297;
                }
            } while (true);
            } finally {dbg.exitSubRule(297);}

            dbg.location(1090,69);
            pushFollow(FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration6173);
            normalInterfaceDeclaration();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 88, interfaceDeclaration_StartIndex); }
        }
        dbg.location(1091, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "interfaceDeclaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "interfaceDeclaration"


    // $ANTLR start "normalInterfaceDeclaration"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1093:1: normalInterfaceDeclaration : ( 'final' )? ( LineTerminator )* 'interface' ( LineTerminator )* qualifiedName ( LineTerminator )* ( inheritance )? ( LineTerminator )* '{' ( LineTerminator )* interfaceElements ( LineTerminator )* '}' ;
    public final void normalInterfaceDeclaration() throws RecognitionException {
        int normalInterfaceDeclaration_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "normalInterfaceDeclaration");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1093, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 89) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:3: ( ( 'final' )? ( LineTerminator )* 'interface' ( LineTerminator )* qualifiedName ( LineTerminator )* ( inheritance )? ( LineTerminator )* '{' ( LineTerminator )* interfaceElements ( LineTerminator )* '}' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:5: ( 'final' )? ( LineTerminator )* 'interface' ( LineTerminator )* qualifiedName ( LineTerminator )* ( inheritance )? ( LineTerminator )* '{' ( LineTerminator )* interfaceElements ( LineTerminator )* '}'
            {
            dbg.location(1094,5);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:5: ( 'final' )?
            int alt298=2;
            try { dbg.enterSubRule(298);
            try { dbg.enterDecision(298);

            int LA298_0 = input.LA(1);

            if ( (LA298_0==118) ) {
                alt298=1;
            }
            } finally {dbg.exitDecision(298);}

            switch (alt298) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'final'
                    {
                    dbg.location(1094,5);
                    match(input,118,FOLLOW_118_in_normalInterfaceDeclaration6185); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(298);}

            dbg.location(1094,14);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:14: ( LineTerminator )*
            try { dbg.enterSubRule(299);

            loop299:
            do {
                int alt299=2;
                try { dbg.enterDecision(299);

                int LA299_0 = input.LA(1);

                if ( (LA299_0==LineTerminator) ) {
                    alt299=1;
                }


                } finally {dbg.exitDecision(299);}

                switch (alt299) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1094,14);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalInterfaceDeclaration6188); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop299;
                }
            } while (true);
            } finally {dbg.exitSubRule(299);}

            dbg.location(1094,30);
            match(input,122,FOLLOW_122_in_normalInterfaceDeclaration6191); if (state.failed) return ;
            dbg.location(1094,42);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:42: ( LineTerminator )*
            try { dbg.enterSubRule(300);

            loop300:
            do {
                int alt300=2;
                try { dbg.enterDecision(300);

                int LA300_0 = input.LA(1);

                if ( (LA300_0==LineTerminator) ) {
                    alt300=1;
                }


                } finally {dbg.exitDecision(300);}

                switch (alt300) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1094,42);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalInterfaceDeclaration6193); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop300;
                }
            } while (true);
            } finally {dbg.exitSubRule(300);}

            dbg.location(1094,58);
            pushFollow(FOLLOW_qualifiedName_in_normalInterfaceDeclaration6196);
            qualifiedName();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1094,72);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:72: ( LineTerminator )*
            try { dbg.enterSubRule(301);

            loop301:
            do {
                int alt301=2;
                try { dbg.enterDecision(301);

                int LA301_0 = input.LA(1);

                if ( (LA301_0==LineTerminator) ) {
                    int LA301_2 = input.LA(2);

                    if ( (synpred382_AS3()) ) {
                        alt301=1;
                    }


                }


                } finally {dbg.exitDecision(301);}

                switch (alt301) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1094,72);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalInterfaceDeclaration6198); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop301;
                }
            } while (true);
            } finally {dbg.exitSubRule(301);}

            dbg.location(1094,88);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:88: ( inheritance )?
            int alt302=2;
            try { dbg.enterSubRule(302);
            try { dbg.enterDecision(302);

            int LA302_0 = input.LA(1);

            if ( (LA302_0==123) ) {
                alt302=1;
            }
            } finally {dbg.exitDecision(302);}

            switch (alt302) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: inheritance
                    {
                    dbg.location(1094,88);
                    pushFollow(FOLLOW_inheritance_in_normalInterfaceDeclaration6201);
                    inheritance();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(302);}

            dbg.location(1094,101);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:101: ( LineTerminator )*
            try { dbg.enterSubRule(303);

            loop303:
            do {
                int alt303=2;
                try { dbg.enterDecision(303);

                int LA303_0 = input.LA(1);

                if ( (LA303_0==LineTerminator) ) {
                    alt303=1;
                }


                } finally {dbg.exitDecision(303);}

                switch (alt303) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1094,101);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalInterfaceDeclaration6204); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop303;
                }
            } while (true);
            } finally {dbg.exitSubRule(303);}

            dbg.location(1094,117);
            match(input,41,FOLLOW_41_in_normalInterfaceDeclaration6207); if (state.failed) return ;
            dbg.location(1094,121);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:121: ( LineTerminator )*
            try { dbg.enterSubRule(304);

            loop304:
            do {
                int alt304=2;
                try { dbg.enterDecision(304);

                int LA304_0 = input.LA(1);

                if ( (LA304_0==LineTerminator) ) {
                    int LA304_1 = input.LA(2);

                    if ( (synpred385_AS3()) ) {
                        alt304=1;
                    }


                }


                } finally {dbg.exitDecision(304);}

                switch (alt304) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1094,121);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalInterfaceDeclaration6209); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop304;
                }
            } while (true);
            } finally {dbg.exitSubRule(304);}

            dbg.location(1094,137);
            pushFollow(FOLLOW_interfaceElements_in_normalInterfaceDeclaration6212);
            interfaceElements();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1094,155);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:155: ( LineTerminator )*
            try { dbg.enterSubRule(305);

            loop305:
            do {
                int alt305=2;
                try { dbg.enterDecision(305);

                int LA305_0 = input.LA(1);

                if ( (LA305_0==LineTerminator) ) {
                    alt305=1;
                }


                } finally {dbg.exitDecision(305);}

                switch (alt305) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1094,155);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_normalInterfaceDeclaration6214); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop305;
                }
            } while (true);
            } finally {dbg.exitSubRule(305);}

            dbg.location(1094,171);
            match(input,42,FOLLOW_42_in_normalInterfaceDeclaration6217); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 89, normalInterfaceDeclaration_StartIndex); }
        }
        dbg.location(1095, 3);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "normalInterfaceDeclaration");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "normalInterfaceDeclaration"


    // $ANTLR start "inheritance"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1105:1: inheritance : 'extends' ( LineTerminator )* qualifiedName ;
    public final void inheritance() throws RecognitionException {
        int inheritance_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "inheritance");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1105, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 90) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1106:2: ( 'extends' ( LineTerminator )* qualifiedName )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1106:4: 'extends' ( LineTerminator )* qualifiedName
            {
            dbg.location(1106,4);
            match(input,123,FOLLOW_123_in_inheritance6237); if (state.failed) return ;
            dbg.location(1106,14);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1106:14: ( LineTerminator )*
            try { dbg.enterSubRule(306);

            loop306:
            do {
                int alt306=2;
                try { dbg.enterDecision(306);

                int LA306_0 = input.LA(1);

                if ( (LA306_0==LineTerminator) ) {
                    alt306=1;
                }


                } finally {dbg.exitDecision(306);}

                switch (alt306) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1106,14);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_inheritance6239); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop306;
                }
            } while (true);
            } finally {dbg.exitSubRule(306);}

            dbg.location(1106,30);
            pushFollow(FOLLOW_qualifiedName_in_inheritance6242);
            qualifiedName();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 90, inheritance_StartIndex); }
        }
        dbg.location(1107, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "inheritance");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "inheritance"


    // $ANTLR start "interfaceImplementations"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1109:1: interfaceImplementations : 'implements' ( LineTerminator )* qualifiedName ( ( LineTerminator )* ',' ( LineTerminator )* qualifiedName )* ;
    public final void interfaceImplementations() throws RecognitionException {
        int interfaceImplementations_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "interfaceImplementations");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1109, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 91) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1110:2: ( 'implements' ( LineTerminator )* qualifiedName ( ( LineTerminator )* ',' ( LineTerminator )* qualifiedName )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1110:4: 'implements' ( LineTerminator )* qualifiedName ( ( LineTerminator )* ',' ( LineTerminator )* qualifiedName )*
            {
            dbg.location(1110,4);
            match(input,124,FOLLOW_124_in_interfaceImplementations6253); if (state.failed) return ;
            dbg.location(1110,17);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1110:17: ( LineTerminator )*
            try { dbg.enterSubRule(307);

            loop307:
            do {
                int alt307=2;
                try { dbg.enterDecision(307);

                int LA307_0 = input.LA(1);

                if ( (LA307_0==LineTerminator) ) {
                    alt307=1;
                }


                } finally {dbg.exitDecision(307);}

                switch (alt307) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1110,17);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_interfaceImplementations6255); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop307;
                }
            } while (true);
            } finally {dbg.exitSubRule(307);}

            dbg.location(1110,33);
            pushFollow(FOLLOW_qualifiedName_in_interfaceImplementations6258);
            qualifiedName();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1110,47);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1110:47: ( ( LineTerminator )* ',' ( LineTerminator )* qualifiedName )*
            try { dbg.enterSubRule(310);

            loop310:
            do {
                int alt310=2;
                try { dbg.enterDecision(310);

                try {
                    isCyclicDecision = true;
                    alt310 = dfa310.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(310);}

                switch (alt310) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1110:48: ( LineTerminator )* ',' ( LineTerminator )* qualifiedName
            	    {
            	    dbg.location(1110,48);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1110:48: ( LineTerminator )*
            	    try { dbg.enterSubRule(308);

            	    loop308:
            	    do {
            	        int alt308=2;
            	        try { dbg.enterDecision(308);

            	        int LA308_0 = input.LA(1);

            	        if ( (LA308_0==LineTerminator) ) {
            	            alt308=1;
            	        }


            	        } finally {dbg.exitDecision(308);}

            	        switch (alt308) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1110,48);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_interfaceImplementations6261); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop308;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(308);}

            	    dbg.location(1110,64);
            	    match(input,39,FOLLOW_39_in_interfaceImplementations6264); if (state.failed) return ;
            	    dbg.location(1110,68);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1110:68: ( LineTerminator )*
            	    try { dbg.enterSubRule(309);

            	    loop309:
            	    do {
            	        int alt309=2;
            	        try { dbg.enterDecision(309);

            	        int LA309_0 = input.LA(1);

            	        if ( (LA309_0==LineTerminator) ) {
            	            alt309=1;
            	        }


            	        } finally {dbg.exitDecision(309);}

            	        switch (alt309) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1110,68);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_interfaceImplementations6266); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop309;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(309);}

            	    dbg.location(1110,84);
            	    pushFollow(FOLLOW_qualifiedName_in_interfaceImplementations6269);
            	    qualifiedName();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop310;
                }
            } while (true);
            } finally {dbg.exitSubRule(310);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 91, interfaceImplementations_StartIndex); }
        }
        dbg.location(1111, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "interfaceImplementations");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "interfaceImplementations"


    // $ANTLR start "classElements"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1113:1: classElements : ( ( LineTerminator )* classElement ( LineTerminator )* )* ;
    public final void classElements() throws RecognitionException {
        int classElements_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "classElements");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1113, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 92) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:2: ( ( ( LineTerminator )* classElement ( LineTerminator )* )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:4: ( ( LineTerminator )* classElement ( LineTerminator )* )*
            {
            dbg.location(1114,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:4: ( ( LineTerminator )* classElement ( LineTerminator )* )*
            try { dbg.enterSubRule(313);

            loop313:
            do {
                int alt313=2;
                try { dbg.enterDecision(313);

                try {
                    isCyclicDecision = true;
                    alt313 = dfa313.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(313);}

                switch (alt313) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:5: ( LineTerminator )* classElement ( LineTerminator )*
            	    {
            	    dbg.location(1114,5);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:5: ( LineTerminator )*
            	    try { dbg.enterSubRule(311);

            	    loop311:
            	    do {
            	        int alt311=2;
            	        try { dbg.enterDecision(311);

            	        int LA311_0 = input.LA(1);

            	        if ( (LA311_0==LineTerminator) ) {
            	            int LA311_2 = input.LA(2);

            	            if ( (synpred392_AS3()) ) {
            	                alt311=1;
            	            }


            	        }


            	        } finally {dbg.exitDecision(311);}

            	        switch (alt311) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1114,5);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classElements6283); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop311;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(311);}

            	    dbg.location(1114,21);
            	    pushFollow(FOLLOW_classElement_in_classElements6286);
            	    classElement();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(1114,34);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:34: ( LineTerminator )*
            	    try { dbg.enterSubRule(312);

            	    loop312:
            	    do {
            	        int alt312=2;
            	        try { dbg.enterDecision(312);

            	        int LA312_0 = input.LA(1);

            	        if ( (LA312_0==LineTerminator) ) {
            	            int LA312_1 = input.LA(2);

            	            if ( (synpred393_AS3()) ) {
            	                alt312=1;
            	            }


            	        }


            	        } finally {dbg.exitDecision(312);}

            	        switch (alt312) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1114,34);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classElements6288); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop312;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(312);}


            	    }
            	    break;

            	default :
            	    break loop313;
                }
            } while (true);
            } finally {dbg.exitSubRule(313);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 92, classElements_StartIndex); }
        }
        dbg.location(1115, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "classElements");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "classElements"


    // $ANTLR start "classMember"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1117:1: classMember : ( ( 'override' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'override' )? ( LineTerminator )* functionDeclaration | ( 'static' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'static' )? ( LineTerminator )* ( functionDeclaration | variableStatement ) );
    public final void classMember() throws RecognitionException {
        int classMember_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "classMember");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1117, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 93) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:2: ( ( 'override' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'override' )? ( LineTerminator )* functionDeclaration | ( 'static' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'static' )? ( LineTerminator )* ( functionDeclaration | variableStatement ) )
            int alt327=2;
            try { dbg.enterDecision(327);

            try {
                isCyclicDecision = true;
                alt327 = dfa327.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(327);}

            switch (alt327) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:4: ( 'override' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'override' )? ( LineTerminator )* functionDeclaration
                    {
                    dbg.location(1118,4);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:4: ( 'override' )?
                    int alt314=2;
                    try { dbg.enterSubRule(314);
                    try { dbg.enterDecision(314);

                    int LA314_0 = input.LA(1);

                    if ( (LA314_0==125) ) {
                        int LA314_1 = input.LA(2);

                        if ( (synpred395_AS3()) ) {
                            alt314=1;
                        }
                    }
                    } finally {dbg.exitDecision(314);}

                    switch (alt314) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'override'
                            {
                            dbg.location(1118,4);
                            match(input,125,FOLLOW_125_in_classMember6302); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(314);}

                    dbg.location(1118,16);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:16: ( LineTerminator )*
                    try { dbg.enterSubRule(315);

                    loop315:
                    do {
                        int alt315=2;
                        try { dbg.enterDecision(315);

                        int LA315_0 = input.LA(1);

                        if ( (LA315_0==LineTerminator) ) {
                            int LA315_2 = input.LA(2);

                            if ( (synpred396_AS3()) ) {
                                alt315=1;
                            }


                        }


                        } finally {dbg.exitDecision(315);}

                        switch (alt315) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1118,16);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classMember6305); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop315;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(315);}

                    dbg.location(1118,32);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:32: ( namespace )?
                    int alt316=2;
                    try { dbg.enterSubRule(316);
                    try { dbg.enterDecision(316);

                    int LA316_0 = input.LA(1);

                    if ( (LA316_0==Identifier||(LA316_0>=119 && LA316_0<=120)||(LA316_0>=130 && LA316_0<=131)) ) {
                        alt316=1;
                    }
                    } finally {dbg.exitDecision(316);}

                    switch (alt316) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: namespace
                            {
                            dbg.location(1118,32);
                            pushFollow(FOLLOW_namespace_in_classMember6308);
                            namespace();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(316);}

                    dbg.location(1118,43);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:43: ( LineTerminator )*
                    try { dbg.enterSubRule(317);

                    loop317:
                    do {
                        int alt317=2;
                        try { dbg.enterDecision(317);

                        int LA317_0 = input.LA(1);

                        if ( (LA317_0==LineTerminator) ) {
                            int LA317_2 = input.LA(2);

                            if ( (synpred398_AS3()) ) {
                                alt317=1;
                            }


                        }


                        } finally {dbg.exitDecision(317);}

                        switch (alt317) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1118,43);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classMember6311); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop317;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(317);}

                    dbg.location(1118,59);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:59: ( 'override' )?
                    int alt318=2;
                    try { dbg.enterSubRule(318);
                    try { dbg.enterDecision(318);

                    int LA318_0 = input.LA(1);

                    if ( (LA318_0==125) ) {
                        alt318=1;
                    }
                    } finally {dbg.exitDecision(318);}

                    switch (alt318) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'override'
                            {
                            dbg.location(1118,59);
                            match(input,125,FOLLOW_125_in_classMember6314); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(318);}

                    dbg.location(1118,71);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:71: ( LineTerminator )*
                    try { dbg.enterSubRule(319);

                    loop319:
                    do {
                        int alt319=2;
                        try { dbg.enterDecision(319);

                        int LA319_0 = input.LA(1);

                        if ( (LA319_0==LineTerminator) ) {
                            alt319=1;
                        }


                        } finally {dbg.exitDecision(319);}

                        switch (alt319) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1118,71);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classMember6317); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop319;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(319);}

                    dbg.location(1118,87);
                    pushFollow(FOLLOW_functionDeclaration_in_classMember6320);
                    functionDeclaration();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:4: ( 'static' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'static' )? ( LineTerminator )* ( functionDeclaration | variableStatement )
                    {
                    dbg.location(1119,4);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:4: ( 'static' )?
                    int alt320=2;
                    try { dbg.enterSubRule(320);
                    try { dbg.enterDecision(320);

                    int LA320_0 = input.LA(1);

                    if ( (LA320_0==126) ) {
                        int LA320_1 = input.LA(2);

                        if ( (synpred402_AS3()) ) {
                            alt320=1;
                        }
                    }
                    } finally {dbg.exitDecision(320);}

                    switch (alt320) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'static'
                            {
                            dbg.location(1119,4);
                            match(input,126,FOLLOW_126_in_classMember6325); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(320);}

                    dbg.location(1119,14);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:14: ( LineTerminator )*
                    try { dbg.enterSubRule(321);

                    loop321:
                    do {
                        int alt321=2;
                        try { dbg.enterDecision(321);

                        int LA321_0 = input.LA(1);

                        if ( (LA321_0==LineTerminator) ) {
                            int LA321_2 = input.LA(2);

                            if ( (synpred403_AS3()) ) {
                                alt321=1;
                            }


                        }


                        } finally {dbg.exitDecision(321);}

                        switch (alt321) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1119,14);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classMember6328); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop321;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(321);}

                    dbg.location(1119,30);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:30: ( namespace )?
                    int alt322=2;
                    try { dbg.enterSubRule(322);
                    try { dbg.enterDecision(322);

                    int LA322_0 = input.LA(1);

                    if ( (LA322_0==Identifier||(LA322_0>=119 && LA322_0<=120)||(LA322_0>=130 && LA322_0<=131)) ) {
                        alt322=1;
                    }
                    } finally {dbg.exitDecision(322);}

                    switch (alt322) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: namespace
                            {
                            dbg.location(1119,30);
                            pushFollow(FOLLOW_namespace_in_classMember6331);
                            namespace();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(322);}

                    dbg.location(1119,41);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:41: ( LineTerminator )*
                    try { dbg.enterSubRule(323);

                    loop323:
                    do {
                        int alt323=2;
                        try { dbg.enterDecision(323);

                        int LA323_0 = input.LA(1);

                        if ( (LA323_0==LineTerminator) ) {
                            int LA323_2 = input.LA(2);

                            if ( (synpred405_AS3()) ) {
                                alt323=1;
                            }


                        }


                        } finally {dbg.exitDecision(323);}

                        switch (alt323) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1119,41);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classMember6334); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop323;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(323);}

                    dbg.location(1119,57);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:57: ( 'static' )?
                    int alt324=2;
                    try { dbg.enterSubRule(324);
                    try { dbg.enterDecision(324);

                    int LA324_0 = input.LA(1);

                    if ( (LA324_0==126) ) {
                        alt324=1;
                    }
                    } finally {dbg.exitDecision(324);}

                    switch (alt324) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'static'
                            {
                            dbg.location(1119,57);
                            match(input,126,FOLLOW_126_in_classMember6337); if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(324);}

                    dbg.location(1119,67);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:67: ( LineTerminator )*
                    try { dbg.enterSubRule(325);

                    loop325:
                    do {
                        int alt325=2;
                        try { dbg.enterDecision(325);

                        int LA325_0 = input.LA(1);

                        if ( (LA325_0==LineTerminator) ) {
                            alt325=1;
                        }


                        } finally {dbg.exitDecision(325);}

                        switch (alt325) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1119,67);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_classMember6340); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop325;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(325);}

                    dbg.location(1119,83);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:83: ( functionDeclaration | variableStatement )
                    int alt326=2;
                    try { dbg.enterSubRule(326);
                    try { dbg.enterDecision(326);

                    int LA326_0 = input.LA(1);

                    if ( (LA326_0==111) ) {
                        alt326=1;
                    }
                    else if ( ((LA326_0>=92 && LA326_0<=93)) ) {
                        alt326=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 326, 0, input);

                        dbg.recognitionException(nvae);
                        throw nvae;
                    }
                    } finally {dbg.exitDecision(326);}

                    switch (alt326) {
                        case 1 :
                            dbg.enterAlt(1);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:84: functionDeclaration
                            {
                            dbg.location(1119,84);
                            pushFollow(FOLLOW_functionDeclaration_in_classMember6344);
                            functionDeclaration();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;
                        case 2 :
                            dbg.enterAlt(2);

                            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:106: variableStatement
                            {
                            dbg.location(1119,106);
                            pushFollow(FOLLOW_variableStatement_in_classMember6348);
                            variableStatement();

                            state._fsp--;
                            if (state.failed) return ;

                            }
                            break;

                    }
                    } finally {dbg.exitSubRule(326);}


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 93, classMember_StartIndex); }
        }
        dbg.location(1120, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "classMember");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "classMember"


    // $ANTLR start "classElement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1122:1: classElement : ( classMember | statement );
    public final void classElement() throws RecognitionException {
        int classElement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "classElement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1122, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 94) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1123:2: ( classMember | statement )
            int alt328=2;
            try { dbg.enterDecision(328);

            try {
                isCyclicDecision = true;
                alt328 = dfa328.predict(input);
            }
            catch (NoViableAltException nvae) {
                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(328);}

            switch (alt328) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1123:4: classMember
                    {
                    dbg.location(1123,4);
                    pushFollow(FOLLOW_classMember_in_classElement6362);
                    classMember();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1124:4: statement
                    {
                    dbg.location(1124,4);
                    pushFollow(FOLLOW_statement_in_classElement6367);
                    statement();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 94, classElement_StartIndex); }
        }
        dbg.location(1125, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "classElement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "classElement"


    // $ANTLR start "interfaceElements"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1127:1: interfaceElements : ( ( LineTerminator )* interfaceElement ( LineTerminator )* )* ;
    public final void interfaceElements() throws RecognitionException {
        int interfaceElements_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "interfaceElements");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1127, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 95) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1128:2: ( ( ( LineTerminator )* interfaceElement ( LineTerminator )* )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1128:4: ( ( LineTerminator )* interfaceElement ( LineTerminator )* )*
            {
            dbg.location(1128,4);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1128:4: ( ( LineTerminator )* interfaceElement ( LineTerminator )* )*
            try { dbg.enterSubRule(331);

            loop331:
            do {
                int alt331=2;
                try { dbg.enterDecision(331);

                try {
                    isCyclicDecision = true;
                    alt331 = dfa331.predict(input);
                }
                catch (NoViableAltException nvae) {
                    dbg.recognitionException(nvae);
                    throw nvae;
                }
                } finally {dbg.exitDecision(331);}

                switch (alt331) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1128:5: ( LineTerminator )* interfaceElement ( LineTerminator )*
            	    {
            	    dbg.location(1128,5);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1128:5: ( LineTerminator )*
            	    try { dbg.enterSubRule(329);

            	    loop329:
            	    do {
            	        int alt329=2;
            	        try { dbg.enterDecision(329);

            	        int LA329_0 = input.LA(1);

            	        if ( (LA329_0==LineTerminator) ) {
            	            alt329=1;
            	        }


            	        } finally {dbg.exitDecision(329);}

            	        switch (alt329) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1128,5);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_interfaceElements6379); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop329;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(329);}

            	    dbg.location(1128,21);
            	    pushFollow(FOLLOW_interfaceElement_in_interfaceElements6382);
            	    interfaceElement();

            	    state._fsp--;
            	    if (state.failed) return ;
            	    dbg.location(1128,38);
            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1128:38: ( LineTerminator )*
            	    try { dbg.enterSubRule(330);

            	    loop330:
            	    do {
            	        int alt330=2;
            	        try { dbg.enterDecision(330);

            	        int LA330_0 = input.LA(1);

            	        if ( (LA330_0==LineTerminator) ) {
            	            int LA330_1 = input.LA(2);

            	            if ( (synpred411_AS3()) ) {
            	                alt330=1;
            	            }


            	        }


            	        } finally {dbg.exitDecision(330);}

            	        switch (alt330) {
            	    	case 1 :
            	    	    dbg.enterAlt(1);

            	    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    	    {
            	    	    dbg.location(1128,38);
            	    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_interfaceElements6384); if (state.failed) return ;

            	    	    }
            	    	    break;

            	    	default :
            	    	    break loop330;
            	        }
            	    } while (true);
            	    } finally {dbg.exitSubRule(330);}


            	    }
            	    break;

            	default :
            	    break loop331;
                }
            } while (true);
            } finally {dbg.exitSubRule(331);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 95, interfaceElements_StartIndex); }
        }
        dbg.location(1129, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "interfaceElements");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "interfaceElements"


    // $ANTLR start "interfaceElement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1131:1: interfaceElement : functionDeclaration ;
    public final void interfaceElement() throws RecognitionException {
        int interfaceElement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "interfaceElement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1131, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 96) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1132:2: ( functionDeclaration )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1132:4: functionDeclaration
            {
            dbg.location(1132,4);
            pushFollow(FOLLOW_functionDeclaration_in_interfaceElement6398);
            functionDeclaration();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 96, interfaceElement_StartIndex); }
        }
        dbg.location(1133, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "interfaceElement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "interfaceElement"


    // $ANTLR start "qualifiedName"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1135:1: qualifiedName : Identifier ( '.' Identifier )* ;
    public final void qualifiedName() throws RecognitionException {
        int qualifiedName_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "qualifiedName");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1135, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 97) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1136:2: ( Identifier ( '.' Identifier )* )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1136:4: Identifier ( '.' Identifier )*
            {
            dbg.location(1136,4);
            match(input,Identifier,FOLLOW_Identifier_in_qualifiedName6411); if (state.failed) return ;
            dbg.location(1136,15);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1136:15: ( '.' Identifier )*
            try { dbg.enterSubRule(332);

            loop332:
            do {
                int alt332=2;
                try { dbg.enterDecision(332);

                int LA332_0 = input.LA(1);

                if ( (LA332_0==45) ) {
                    int LA332_2 = input.LA(2);

                    if ( (LA332_2==Identifier) ) {
                        int LA332_3 = input.LA(3);

                        if ( (synpred413_AS3()) ) {
                            alt332=1;
                        }


                    }


                }


                } finally {dbg.exitDecision(332);}

                switch (alt332) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1136:16: '.' Identifier
            	    {
            	    dbg.location(1136,16);
            	    match(input,45,FOLLOW_45_in_qualifiedName6414); if (state.failed) return ;
            	    dbg.location(1136,20);
            	    match(input,Identifier,FOLLOW_Identifier_in_qualifiedName6416); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop332;
                }
            } while (true);
            } finally {dbg.exitSubRule(332);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 97, qualifiedName_StartIndex); }
        }
        dbg.location(1137, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "qualifiedName");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "qualifiedName"


    // $ANTLR start "defaultArgumentValue"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1139:1: defaultArgumentValue : '=' ( LineTerminator )* assignmentExpressionNoIn ;
    public final void defaultArgumentValue() throws RecognitionException {
        int defaultArgumentValue_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "defaultArgumentValue");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1139, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 98) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1140:2: ( '=' ( LineTerminator )* assignmentExpressionNoIn )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1140:4: '=' ( LineTerminator )* assignmentExpressionNoIn
            {
            dbg.location(1140,4);
            match(input,80,FOLLOW_80_in_defaultArgumentValue6431); if (state.failed) return ;
            dbg.location(1140,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1140:8: ( LineTerminator )*
            try { dbg.enterSubRule(333);

            loop333:
            do {
                int alt333=2;
                try { dbg.enterDecision(333);

                int LA333_0 = input.LA(1);

                if ( (LA333_0==LineTerminator) ) {
                    alt333=1;
                }


                } finally {dbg.exitDecision(333);}

                switch (alt333) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1140,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_defaultArgumentValue6433); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop333;
                }
            } while (true);
            } finally {dbg.exitSubRule(333);}

            dbg.location(1140,24);
            pushFollow(FOLLOW_assignmentExpressionNoIn_in_defaultArgumentValue6436);
            assignmentExpressionNoIn();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 98, defaultArgumentValue_StartIndex); }
        }
        dbg.location(1141, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "defaultArgumentValue");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "defaultArgumentValue"


    // $ANTLR start "useNamespaceStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1143:1: useNamespaceStatement : 'use' ( LineTerminator )* 'namespace' ( LineTerminator )* Identifier ( ( LineTerminator )* | ';' ) ;
    public final void useNamespaceStatement() throws RecognitionException {
        int useNamespaceStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "useNamespaceStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1143, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 99) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:2: ( 'use' ( LineTerminator )* 'namespace' ( LineTerminator )* Identifier ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:4: 'use' ( LineTerminator )* 'namespace' ( LineTerminator )* Identifier ( ( LineTerminator )* | ';' )
            {
            dbg.location(1144,4);
            match(input,127,FOLLOW_127_in_useNamespaceStatement6448); if (state.failed) return ;
            dbg.location(1144,10);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:10: ( LineTerminator )*
            try { dbg.enterSubRule(334);

            loop334:
            do {
                int alt334=2;
                try { dbg.enterDecision(334);

                int LA334_0 = input.LA(1);

                if ( (LA334_0==LineTerminator) ) {
                    alt334=1;
                }


                } finally {dbg.exitDecision(334);}

                switch (alt334) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1144,10);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_useNamespaceStatement6450); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop334;
                }
            } while (true);
            } finally {dbg.exitSubRule(334);}

            dbg.location(1144,26);
            match(input,128,FOLLOW_128_in_useNamespaceStatement6453); if (state.failed) return ;
            dbg.location(1144,38);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:38: ( LineTerminator )*
            try { dbg.enterSubRule(335);

            loop335:
            do {
                int alt335=2;
                try { dbg.enterDecision(335);

                int LA335_0 = input.LA(1);

                if ( (LA335_0==LineTerminator) ) {
                    alt335=1;
                }


                } finally {dbg.exitDecision(335);}

                switch (alt335) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1144,38);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_useNamespaceStatement6455); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop335;
                }
            } while (true);
            } finally {dbg.exitSubRule(335);}

            dbg.location(1144,54);
            match(input,Identifier,FOLLOW_Identifier_in_useNamespaceStatement6458); if (state.failed) return ;
            dbg.location(1144,65);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:65: ( ( LineTerminator )* | ';' )
            int alt337=2;
            try { dbg.enterSubRule(337);
            try { dbg.enterDecision(337);

            int LA337_0 = input.LA(1);

            if ( (LA337_0==EOF||LA337_0==LineTerminator||LA337_0==Identifier||(LA337_0>=NullLiteral && LA337_0<=StringLiteral)||(LA337_0>=34 && LA337_0<=36)||LA337_0==38||(LA337_0>=41 && LA337_0<=42)||LA337_0==44||(LA337_0>=47 && LA337_0<=56)||(LA337_0>=92 && LA337_0<=93)||(LA337_0>=95 && LA337_0<=108)||LA337_0==111||LA337_0==116||(LA337_0>=118 && LA337_0<=120)||(LA337_0>=125 && LA337_0<=127)||(LA337_0>=129 && LA337_0<=131)) ) {
                alt337=1;
            }
            else if ( (LA337_0==94) ) {
                int LA337_2 = input.LA(2);

                if ( (synpred418_AS3()) ) {
                    alt337=1;
                }
                else if ( (true) ) {
                    alt337=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 337, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 337, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(337);}

            switch (alt337) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:66: ( LineTerminator )*
                    {
                    dbg.location(1144,66);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:66: ( LineTerminator )*
                    try { dbg.enterSubRule(336);

                    loop336:
                    do {
                        int alt336=2;
                        try { dbg.enterDecision(336);

                        int LA336_0 = input.LA(1);

                        if ( (LA336_0==LineTerminator) ) {
                            int LA336_1 = input.LA(2);

                            if ( (synpred417_AS3()) ) {
                                alt336=1;
                            }


                        }


                        } finally {dbg.exitDecision(336);}

                        switch (alt336) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1144,66);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_useNamespaceStatement6461); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop336;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(336);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:84: ';'
                    {
                    dbg.location(1144,84);
                    match(input,94,FOLLOW_94_in_useNamespaceStatement6466); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(337);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 99, useNamespaceStatement_StartIndex); }
        }
        dbg.location(1145, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "useNamespaceStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "useNamespaceStatement"


    // $ANTLR start "metaDataStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1147:1: metaDataStatement : '[' ( LineTerminator )* Identifier ( LineTerminator )* ( formalParameterList )? ( LineTerminator )* ']' ;
    public final void metaDataStatement() throws RecognitionException {
        int metaDataStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "metaDataStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1147, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 100) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1148:2: ( '[' ( LineTerminator )* Identifier ( LineTerminator )* ( formalParameterList )? ( LineTerminator )* ']' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1148:4: '[' ( LineTerminator )* Identifier ( LineTerminator )* ( formalParameterList )? ( LineTerminator )* ']'
            {
            dbg.location(1148,4);
            match(input,38,FOLLOW_38_in_metaDataStatement6478); if (state.failed) return ;
            dbg.location(1148,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1148:8: ( LineTerminator )*
            try { dbg.enterSubRule(338);

            loop338:
            do {
                int alt338=2;
                try { dbg.enterDecision(338);

                int LA338_0 = input.LA(1);

                if ( (LA338_0==LineTerminator) ) {
                    alt338=1;
                }


                } finally {dbg.exitDecision(338);}

                switch (alt338) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1148,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_metaDataStatement6480); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop338;
                }
            } while (true);
            } finally {dbg.exitSubRule(338);}

            dbg.location(1148,24);
            match(input,Identifier,FOLLOW_Identifier_in_metaDataStatement6483); if (state.failed) return ;
            dbg.location(1148,35);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1148:35: ( LineTerminator )*
            try { dbg.enterSubRule(339);

            loop339:
            do {
                int alt339=2;
                try { dbg.enterDecision(339);

                int LA339_0 = input.LA(1);

                if ( (LA339_0==LineTerminator) ) {
                    int LA339_2 = input.LA(2);

                    if ( (synpred420_AS3()) ) {
                        alt339=1;
                    }


                }


                } finally {dbg.exitDecision(339);}

                switch (alt339) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1148,35);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_metaDataStatement6485); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop339;
                }
            } while (true);
            } finally {dbg.exitSubRule(339);}

            dbg.location(1148,51);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1148:51: ( formalParameterList )?
            int alt340=2;
            try { dbg.enterSubRule(340);
            try { dbg.enterDecision(340);

            int LA340_0 = input.LA(1);

            if ( (LA340_0==36) ) {
                alt340=1;
            }
            } finally {dbg.exitDecision(340);}

            switch (alt340) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: formalParameterList
                    {
                    dbg.location(1148,51);
                    pushFollow(FOLLOW_formalParameterList_in_metaDataStatement6488);
                    formalParameterList();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(340);}

            dbg.location(1148,72);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1148:72: ( LineTerminator )*
            try { dbg.enterSubRule(341);

            loop341:
            do {
                int alt341=2;
                try { dbg.enterDecision(341);

                int LA341_0 = input.LA(1);

                if ( (LA341_0==LineTerminator) ) {
                    alt341=1;
                }


                } finally {dbg.exitDecision(341);}

                switch (alt341) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1148,72);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_metaDataStatement6491); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop341;
                }
            } while (true);
            } finally {dbg.exitSubRule(341);}

            dbg.location(1148,88);
            match(input,40,FOLLOW_40_in_metaDataStatement6494); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 100, metaDataStatement_StartIndex); }
        }
        dbg.location(1149, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "metaDataStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "metaDataStatement"


    // $ANTLR start "includeStatement"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1151:1: includeStatement : 'include' ( LineTerminator )* StringLiteral ( ( LineTerminator )* | ';' ) ;
    public final void includeStatement() throws RecognitionException {
        int includeStatement_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "includeStatement");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1151, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 101) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:2: ( 'include' ( LineTerminator )* StringLiteral ( ( LineTerminator )* | ';' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:4: 'include' ( LineTerminator )* StringLiteral ( ( LineTerminator )* | ';' )
            {
            dbg.location(1152,4);
            match(input,129,FOLLOW_129_in_includeStatement6506); if (state.failed) return ;
            dbg.location(1152,14);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:14: ( LineTerminator )*
            try { dbg.enterSubRule(342);

            loop342:
            do {
                int alt342=2;
                try { dbg.enterDecision(342);

                int LA342_0 = input.LA(1);

                if ( (LA342_0==LineTerminator) ) {
                    alt342=1;
                }


                } finally {dbg.exitDecision(342);}

                switch (alt342) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1152,14);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_includeStatement6508); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop342;
                }
            } while (true);
            } finally {dbg.exitSubRule(342);}

            dbg.location(1152,30);
            match(input,StringLiteral,FOLLOW_StringLiteral_in_includeStatement6511); if (state.failed) return ;
            dbg.location(1152,44);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:44: ( ( LineTerminator )* | ';' )
            int alt344=2;
            try { dbg.enterSubRule(344);
            try { dbg.enterDecision(344);

            int LA344_0 = input.LA(1);

            if ( (LA344_0==EOF||LA344_0==LineTerminator||LA344_0==Identifier||(LA344_0>=NullLiteral && LA344_0<=StringLiteral)||(LA344_0>=34 && LA344_0<=36)||LA344_0==38||(LA344_0>=41 && LA344_0<=42)||LA344_0==44||(LA344_0>=47 && LA344_0<=56)||(LA344_0>=92 && LA344_0<=93)||(LA344_0>=95 && LA344_0<=108)||LA344_0==111||LA344_0==116||(LA344_0>=118 && LA344_0<=120)||(LA344_0>=125 && LA344_0<=127)||(LA344_0>=129 && LA344_0<=131)) ) {
                alt344=1;
            }
            else if ( (LA344_0==94) ) {
                int LA344_2 = input.LA(2);

                if ( (synpred425_AS3()) ) {
                    alt344=1;
                }
                else if ( (true) ) {
                    alt344=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 344, 2, input);

                    dbg.recognitionException(nvae);
                    throw nvae;
                }
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 344, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }
            } finally {dbg.exitDecision(344);}

            switch (alt344) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:45: ( LineTerminator )*
                    {
                    dbg.location(1152,45);
                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:45: ( LineTerminator )*
                    try { dbg.enterSubRule(343);

                    loop343:
                    do {
                        int alt343=2;
                        try { dbg.enterDecision(343);

                        int LA343_0 = input.LA(1);

                        if ( (LA343_0==LineTerminator) ) {
                            int LA343_1 = input.LA(2);

                            if ( (synpred424_AS3()) ) {
                                alt343=1;
                            }


                        }


                        } finally {dbg.exitDecision(343);}

                        switch (alt343) {
                    	case 1 :
                    	    dbg.enterAlt(1);

                    	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
                    	    {
                    	    dbg.location(1152,45);
                    	    match(input,LineTerminator,FOLLOW_LineTerminator_in_includeStatement6514); if (state.failed) return ;

                    	    }
                    	    break;

                    	default :
                    	    break loop343;
                        }
                    } while (true);
                    } finally {dbg.exitSubRule(343);}


                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:63: ';'
                    {
                    dbg.location(1152,63);
                    match(input,94,FOLLOW_94_in_includeStatement6519); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(344);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 101, includeStatement_StartIndex); }
        }
        dbg.location(1153, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "includeStatement");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "includeStatement"


    // $ANTLR start "namespace"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1155:1: namespace : ( 'public' | 'private' | 'protected' | 'internal' | qualifiedName );
    public final void namespace() throws RecognitionException {
        int namespace_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "namespace");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1155, 1);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 102) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1156:2: ( 'public' | 'private' | 'protected' | 'internal' | qualifiedName )
            int alt345=5;
            try { dbg.enterDecision(345);

            switch ( input.LA(1) ) {
            case 119:
                {
                alt345=1;
                }
                break;
            case 130:
                {
                alt345=2;
                }
                break;
            case 131:
                {
                alt345=3;
                }
                break;
            case 120:
                {
                alt345=4;
                }
                break;
            case Identifier:
                {
                alt345=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 345, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(345);}

            switch (alt345) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1156:4: 'public'
                    {
                    dbg.location(1156,4);
                    match(input,119,FOLLOW_119_in_namespace6531); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1157:4: 'private'
                    {
                    dbg.location(1157,4);
                    match(input,130,FOLLOW_130_in_namespace6536); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1158:4: 'protected'
                    {
                    dbg.location(1158,4);
                    match(input,131,FOLLOW_131_in_namespace6541); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    dbg.enterAlt(4);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1159:4: 'internal'
                    {
                    dbg.location(1159,4);
                    match(input,120,FOLLOW_120_in_namespace6546); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    dbg.enterAlt(5);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1160:4: qualifiedName
                    {
                    dbg.location(1160,4);
                    pushFollow(FOLLOW_qualifiedName_in_namespace6551);
                    qualifiedName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 102, namespace_StartIndex); }
        }
        dbg.location(1161, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "namespace");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "namespace"


    // $ANTLR start "typeInformation"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1163:2: typeInformation : ':' ( LineTerminator )* ( type | 'void' | '*' ) ;
    public final void typeInformation() throws RecognitionException {
        int typeInformation_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeInformation");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1163, 2);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 103) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1164:2: ( ':' ( LineTerminator )* ( type | 'void' | '*' ) )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1164:4: ':' ( LineTerminator )* ( type | 'void' | '*' )
            {
            dbg.location(1164,4);
            match(input,43,FOLLOW_43_in_typeInformation6564); if (state.failed) return ;
            dbg.location(1164,8);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1164:8: ( LineTerminator )*
            try { dbg.enterSubRule(346);

            loop346:
            do {
                int alt346=2;
                try { dbg.enterDecision(346);

                int LA346_0 = input.LA(1);

                if ( (LA346_0==LineTerminator) ) {
                    alt346=1;
                }


                } finally {dbg.exitDecision(346);}

                switch (alt346) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1164,8);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_typeInformation6566); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop346;
                }
            } while (true);
            } finally {dbg.exitSubRule(346);}

            dbg.location(1164,24);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1164:24: ( type | 'void' | '*' )
            int alt347=3;
            try { dbg.enterSubRule(347);
            try { dbg.enterDecision(347);

            switch ( input.LA(1) ) {
            case Identifier:
                {
                alt347=1;
                }
                break;
            case 50:
                {
                alt347=2;
                }
                break;
            case 57:
                {
                alt347=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 347, 0, input);

                dbg.recognitionException(nvae);
                throw nvae;
            }

            } finally {dbg.exitDecision(347);}

            switch (alt347) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1164:26: type
                    {
                    dbg.location(1164,26);
                    pushFollow(FOLLOW_type_in_typeInformation6571);
                    type();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;
                case 2 :
                    dbg.enterAlt(2);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1164:33: 'void'
                    {
                    dbg.location(1164,33);
                    match(input,50,FOLLOW_50_in_typeInformation6575); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    dbg.enterAlt(3);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1164:42: '*'
                    {
                    dbg.location(1164,42);
                    match(input,57,FOLLOW_57_in_typeInformation6579); if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(347);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 103, typeInformation_StartIndex); }
        }
        dbg.location(1165, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeInformation");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeInformation"


    // $ANTLR start "type"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1167:2: type : qualifiedName ( typeModifier )? ;
    public final void type() throws RecognitionException {
        int type_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "type");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1167, 2);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 104) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1168:2: ( qualifiedName ( typeModifier )? )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1168:4: qualifiedName ( typeModifier )?
            {
            dbg.location(1168,4);
            pushFollow(FOLLOW_qualifiedName_in_type6594);
            qualifiedName();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1168,18);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1168:18: ( typeModifier )?
            int alt348=2;
            try { dbg.enterSubRule(348);
            try { dbg.enterDecision(348);

            int LA348_0 = input.LA(1);

            if ( (LA348_0==132) ) {
                alt348=1;
            }
            } finally {dbg.exitDecision(348);}

            switch (alt348) {
                case 1 :
                    dbg.enterAlt(1);

                    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: typeModifier
                    {
                    dbg.location(1168,18);
                    pushFollow(FOLLOW_typeModifier_in_type6596);
                    typeModifier();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }
            } finally {dbg.exitSubRule(348);}


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 104, type_StartIndex); }
        }
        dbg.location(1169, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "type");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "type"


    // $ANTLR start "typeModifier"
    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1171:2: typeModifier : '.<' ( LineTerminator )* type ( LineTerminator )* '>' ;
    public final void typeModifier() throws RecognitionException {
        int typeModifier_StartIndex = input.index();
        try { dbg.enterRule(getGrammarFileName(), "typeModifier");
        if ( getRuleLevel()==0 ) {dbg.commence();}
        incRuleLevel();
        dbg.location(1171, 2);

        try {
            if ( state.backtracking>0 && alreadyParsedRule(input, 105) ) { return ; }
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1172:2: ( '.<' ( LineTerminator )* type ( LineTerminator )* '>' )
            dbg.enterAlt(1);

            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1172:4: '.<' ( LineTerminator )* type ( LineTerminator )* '>'
            {
            dbg.location(1172,4);
            match(input,132,FOLLOW_132_in_typeModifier6611); if (state.failed) return ;
            dbg.location(1172,9);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1172:9: ( LineTerminator )*
            try { dbg.enterSubRule(349);

            loop349:
            do {
                int alt349=2;
                try { dbg.enterDecision(349);

                int LA349_0 = input.LA(1);

                if ( (LA349_0==LineTerminator) ) {
                    alt349=1;
                }


                } finally {dbg.exitDecision(349);}

                switch (alt349) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1172,9);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_typeModifier6613); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop349;
                }
            } while (true);
            } finally {dbg.exitSubRule(349);}

            dbg.location(1172,25);
            pushFollow(FOLLOW_type_in_typeModifier6616);
            type();

            state._fsp--;
            if (state.failed) return ;
            dbg.location(1172,30);
            // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1172:30: ( LineTerminator )*
            try { dbg.enterSubRule(350);

            loop350:
            do {
                int alt350=2;
                try { dbg.enterDecision(350);

                int LA350_0 = input.LA(1);

                if ( (LA350_0==LineTerminator) ) {
                    alt350=1;
                }


                } finally {dbg.exitDecision(350);}

                switch (alt350) {
            	case 1 :
            	    dbg.enterAlt(1);

            	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
            	    {
            	    dbg.location(1172,30);
            	    match(input,LineTerminator,FOLLOW_LineTerminator_in_typeModifier6618); if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop350;
                }
            } while (true);
            } finally {dbg.exitSubRule(350);}

            dbg.location(1172,46);
            match(input,64,FOLLOW_64_in_typeModifier6621); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
            if ( state.backtracking>0 ) { memoize(input, 105, typeModifier_StartIndex); }
        }
        dbg.location(1173, 2);

        }
        finally {
            dbg.exitRule(getGrammarFileName(), "typeModifier");
            decRuleLevel();
            if ( getRuleLevel()==0 ) {dbg.terminate();}
        }

        return ;
    }
    // $ANTLR end "typeModifier"

    // $ANTLR start synpred2_AS3
    public final void synpred2_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:39: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:36:39: LineTerminator
        {
        dbg.location(36,39);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred2_AS350); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred2_AS3

    // $ANTLR start synpred11_AS3
    public final void synpred11_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:693:4: ( Identifier )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:693:4: Identifier
        {
        dbg.location(693,4);
        match(input,Identifier,FOLLOW_Identifier_in_synpred11_AS33531); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred11_AS3

    // $ANTLR start synpred12_AS3
    public final void synpred12_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:694:4: ( qualifiedName )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:694:4: qualifiedName
        {
        dbg.location(694,4);
        pushFollow(FOLLOW_qualifiedName_in_synpred12_AS33536);
        qualifiedName();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred12_AS3

    // $ANTLR start synpred18_AS3
    public final void synpred18_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:8: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:702:8: LineTerminator
        {
        dbg.location(702,8);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred18_AS33581); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred18_AS3

    // $ANTLR start synpred40_AS3
    public final void synpred40_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:116: ( ( LineTerminator )* memberExpressionSuffix )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:116: ( LineTerminator )* memberExpressionSuffix
        {
        dbg.location(720,116);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:720:116: ( LineTerminator )*
        try { dbg.enterSubRule(361);

        loop361:
        do {
            int alt361=2;
            try { dbg.enterDecision(361);

            int LA361_0 = input.LA(1);

            if ( (LA361_0==LineTerminator) ) {
                alt361=1;
            }


            } finally {dbg.exitDecision(361);}

            switch (alt361) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(720,116);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred40_AS33721); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop361;
            }
        } while (true);
        } finally {dbg.exitSubRule(361);}

        dbg.location(720,132);
        pushFollow(FOLLOW_memberExpressionSuffix_in_synpred40_AS33724);
        memberExpressionSuffix();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred40_AS3

    // $ANTLR start synpred42_AS3
    public final void synpred42_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:729:4: ( memberExpression )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:729:4: memberExpression
        {
        dbg.location(729,4);
        pushFollow(FOLLOW_memberExpression_in_synpred42_AS33755);
        memberExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred42_AS3

    // $ANTLR start synpred46_AS3
    public final void synpred46_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:51: ( ( LineTerminator )* callExpressionSuffix )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:51: ( LineTerminator )* callExpressionSuffix
        {
        dbg.location(734,51);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:734:51: ( LineTerminator )*
        try { dbg.enterSubRule(362);

        loop362:
        do {
            int alt362=2;
            try { dbg.enterDecision(362);

            int LA362_0 = input.LA(1);

            if ( (LA362_0==LineTerminator) ) {
                alt362=1;
            }


            } finally {dbg.exitDecision(362);}

            switch (alt362) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(734,51);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred46_AS33785); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop362;
            }
        } while (true);
        } finally {dbg.exitSubRule(362);}

        dbg.location(734,67);
        pushFollow(FOLLOW_callExpressionSuffix_in_synpred46_AS33788);
        callExpressionSuffix();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred46_AS3

    // $ANTLR start synpred60_AS3
    public final void synpred60_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:756:4: ( callExpression )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:756:4: callExpression
        {
        dbg.location(756,4);
        pushFollow(FOLLOW_callExpression_in_synpred60_AS33911);
        callExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred60_AS3

    // $ANTLR start synpred61_AS3
    public final void synpred61_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:761:4: ( leftHandSideExpression '++' )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:761:4: leftHandSideExpression '++'
        {
        dbg.location(761,4);
        pushFollow(FOLLOW_leftHandSideExpression_in_synpred61_AS33927);
        leftHandSideExpression();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(761,27);
        match(input,47,FOLLOW_47_in_synpred61_AS33929); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred61_AS3

    // $ANTLR start synpred62_AS3
    public final void synpred62_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:762:4: ( leftHandSideExpression '--' )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:762:4: leftHandSideExpression '--'
        {
        dbg.location(762,4);
        pushFollow(FOLLOW_leftHandSideExpression_in_synpred62_AS33934);
        leftHandSideExpression();

        state._fsp--;
        if (state.failed) return ;
        dbg.location(762,27);
        match(input,48,FOLLOW_48_in_synpred62_AS33936); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred62_AS3

    // $ANTLR start synpred81_AS3
    public final void synpred81_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:30: ( ( LineTerminator )* ( '+' | '-' ) ( LineTerminator )* multiplicativeExpression )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:30: ( LineTerminator )* ( '+' | '-' ) ( LineTerminator )* multiplicativeExpression
        {
        dbg.location(776,30);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:30: ( LineTerminator )*
        try { dbg.enterSubRule(372);

        loop372:
        do {
            int alt372=2;
            try { dbg.enterDecision(372);

            int LA372_0 = input.LA(1);

            if ( (LA372_0==LineTerminator) ) {
                alt372=1;
            }


            } finally {dbg.exitDecision(372);}

            switch (alt372) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(776,30);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred81_AS34045); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop372;
            }
        } while (true);
        } finally {dbg.exitSubRule(372);}

        dbg.location(776,46);
        if ( (input.LA(1)>=53 && input.LA(1)<=54) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            dbg.recognitionException(mse);
            throw mse;
        }

        dbg.location(776,58);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:776:58: ( LineTerminator )*
        try { dbg.enterSubRule(373);

        loop373:
        do {
            int alt373=2;
            try { dbg.enterDecision(373);

            int LA373_0 = input.LA(1);

            if ( (LA373_0==LineTerminator) ) {
                alt373=1;
            }


            } finally {dbg.exitDecision(373);}

            switch (alt373) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(776,58);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred81_AS34056); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop373;
            }
        } while (true);
        } finally {dbg.exitSubRule(373);}

        dbg.location(776,74);
        pushFollow(FOLLOW_multiplicativeExpression_in_synpred81_AS34059);
        multiplicativeExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred81_AS3

    // $ANTLR start synpred95_AS3
    public final void synpred95_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:21: ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' | 'in' ) ( LineTerminator )* shiftExpression )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:21: ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' | 'in' ) ( LineTerminator )* shiftExpression
        {
        dbg.location(784,21);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:21: ( LineTerminator )*
        try { dbg.enterSubRule(376);

        loop376:
        do {
            int alt376=2;
            try { dbg.enterDecision(376);

            int LA376_0 = input.LA(1);

            if ( (LA376_0==LineTerminator) ) {
                alt376=1;
            }


            } finally {dbg.exitDecision(376);}

            switch (alt376) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(784,21);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred95_AS34109); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop376;
            }
        } while (true);
        } finally {dbg.exitSubRule(376);}

        dbg.location(784,37);
        if ( (input.LA(1)>=63 && input.LA(1)<=69) ) {
            input.consume();
            state.errorRecovery=false;state.failed=false;
        }
        else {
            if (state.backtracking>0) {state.failed=true; return ;}
            MismatchedSetException mse = new MismatchedSetException(null,input);
            dbg.recognitionException(mse);
            throw mse;
        }

        dbg.location(784,92);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:784:92: ( LineTerminator )*
        try { dbg.enterSubRule(377);

        loop377:
        do {
            int alt377=2;
            try { dbg.enterDecision(377);

            int LA377_0 = input.LA(1);

            if ( (LA377_0==LineTerminator) ) {
                alt377=1;
            }


            } finally {dbg.exitDecision(377);}

            switch (alt377) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(784,92);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred95_AS34140); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop377;
            }
        } while (true);
        } finally {dbg.exitSubRule(377);}

        dbg.location(784,108);
        pushFollow(FOLLOW_shiftExpression_in_synpred95_AS34143);
        shiftExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred95_AS3

    // $ANTLR start synpred156_AS3
    public final void synpred156_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:848:4: ( conditionalExpression )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:848:4: conditionalExpression
        {
        dbg.location(848,4);
        pushFollow(FOLLOW_conditionalExpression_in_synpred156_AS34597);
        conditionalExpression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred156_AS3

    // $ANTLR start synpred159_AS3
    public final void synpred159_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:853:4: ( conditionalExpressionNoIn )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:853:4: conditionalExpressionNoIn
        {
        dbg.location(853,4);
        pushFollow(FOLLOW_conditionalExpressionNoIn_in_synpred159_AS34624);
        conditionalExpressionNoIn();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred159_AS3

    // $ANTLR start synpred179_AS3
    public final void synpred179_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:874:4: ( blockStatement )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:874:4: blockStatement
        {
        dbg.location(874,4);
        pushFollow(FOLLOW_blockStatement_in_synpred179_AS34763);
        blockStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred179_AS3

    // $ANTLR start synpred182_AS3
    public final void synpred182_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:877:4: ( expressionStatement )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:877:4: expressionStatement
        {
        dbg.location(877,4);
        pushFollow(FOLLOW_expressionStatement_in_synpred182_AS34778);
        expressionStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred182_AS3

    // $ANTLR start synpred189_AS3
    public final void synpred189_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:884:4: ( labelledStatement )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:884:4: labelledStatement
        {
        dbg.location(884,4);
        pushFollow(FOLLOW_labelledStatement_in_synpred189_AS34813);
        labelledStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred189_AS3

    // $ANTLR start synpred196_AS3
    public final void synpred196_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:8: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:8: LineTerminator
        {
        dbg.location(895,8);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred196_AS34861); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred196_AS3

    // $ANTLR start synpred197_AS3
    public final void synpred197_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:24: ( statementList )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:895:24: statementList
        {
        dbg.location(895,24);
        pushFollow(FOLLOW_statementList_in_synpred197_AS34864);
        statementList();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred197_AS3

    // $ANTLR start synpred200_AS3
    public final void synpred200_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:899:31: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:899:31: LineTerminator
        {
        dbg.location(899,31);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred200_AS34888); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred200_AS3

    // $ANTLR start synpred204_AS3
    public final void synpred204_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:63: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:63: LineTerminator
        {
        dbg.location(903,63);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred204_AS34917); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred204_AS3

    // $ANTLR start synpred205_AS3
    public final void synpred205_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:63: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:63: ( LineTerminator )*
        {
        dbg.location(903,63);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:903:63: ( LineTerminator )*
        try { dbg.enterSubRule(418);

        loop418:
        do {
            int alt418=2;
            try { dbg.enterDecision(418);

            int LA418_0 = input.LA(1);

            if ( (LA418_0==LineTerminator) ) {
                alt418=1;
            }


            } finally {dbg.exitDecision(418);}

            switch (alt418) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(903,63);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred205_AS34917); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop418;
            }
        } while (true);
        } finally {dbg.exitSubRule(418);}


        }
    }
    // $ANTLR end synpred205_AS3

    // $ANTLR start synpred212_AS3
    public final void synpred212_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:15: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:15: LineTerminator
        {
        dbg.location(915,15);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred212_AS34986); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred212_AS3

    // $ANTLR start synpred214_AS3
    public final void synpred214_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:48: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:915:48: LineTerminator
        {
        dbg.location(915,48);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred214_AS34992); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred214_AS3

    // $ANTLR start synpred216_AS3
    public final void synpred216_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:15: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:15: LineTerminator
        {
        dbg.location(919,15);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred216_AS35009); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred216_AS3

    // $ANTLR start synpred218_AS3
    public final void synpred218_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:48: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:919:48: LineTerminator
        {
        dbg.location(919,48);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred218_AS35015); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred218_AS3

    // $ANTLR start synpred222_AS3
    public final void synpred222_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:16: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:16: LineTerminator
        {
        dbg.location(935,16);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred222_AS35079); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred222_AS3

    // $ANTLR start synpred223_AS3
    public final void synpred223_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:16: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:16: ( LineTerminator )*
        {
        dbg.location(935,16);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:935:16: ( LineTerminator )*
        try { dbg.enterSubRule(423);

        loop423:
        do {
            int alt423=2;
            try { dbg.enterDecision(423);

            int LA423_0 = input.LA(1);

            if ( (LA423_0==LineTerminator) ) {
                alt423=1;
            }


            } finally {dbg.exitDecision(423);}

            switch (alt423) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(935,16);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred223_AS35079); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop423;
            }
        } while (true);
        } finally {dbg.exitSubRule(423);}


        }
    }
    // $ANTLR end synpred223_AS3

    // $ANTLR start synpred230_AS3
    public final void synpred230_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:103: ( ( LineTerminator )* 'else' ( LineTerminator )* statement )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:103: ( LineTerminator )* 'else' ( LineTerminator )* statement
        {
        dbg.location(939,103);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:103: ( LineTerminator )*
        try { dbg.enterSubRule(424);

        loop424:
        do {
            int alt424=2;
            try { dbg.enterDecision(424);

            int LA424_0 = input.LA(1);

            if ( (LA424_0==LineTerminator) ) {
                alt424=1;
            }


            } finally {dbg.exitDecision(424);}

            switch (alt424) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(939,103);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred230_AS35119); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop424;
            }
        } while (true);
        } finally {dbg.exitSubRule(424);}

        dbg.location(939,119);
        match(input,96,FOLLOW_96_in_synpred230_AS35122); if (state.failed) return ;
        dbg.location(939,126);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:939:126: ( LineTerminator )*
        try { dbg.enterSubRule(425);

        loop425:
        do {
            int alt425=2;
            try { dbg.enterDecision(425);

            int LA425_0 = input.LA(1);

            if ( (LA425_0==LineTerminator) ) {
                alt425=1;
            }


            } finally {dbg.exitDecision(425);}

            switch (alt425) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(939,126);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred230_AS35124); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop425;
            }
        } while (true);
        } finally {dbg.exitSubRule(425);}

        dbg.location(939,142);
        pushFollow(FOLLOW_statement_in_synpred230_AS35127);
        statement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred230_AS3

    // $ANTLR start synpred233_AS3
    public final void synpred233_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:945:4: ( forStatement )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:945:4: forStatement
        {
        dbg.location(945,4);
        pushFollow(FOLLOW_forStatement_in_synpred233_AS35150);
        forStatement();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred233_AS3

    // $ANTLR start synpred237_AS3
    public final void synpred237_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:95: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:95: LineTerminator
        {
        dbg.location(950,95);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred237_AS35189); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred237_AS3

    // $ANTLR start synpred238_AS3
    public final void synpred238_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:95: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:95: ( LineTerminator )*
        {
        dbg.location(950,95);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:950:95: ( LineTerminator )*
        try { dbg.enterSubRule(426);

        loop426:
        do {
            int alt426=2;
            try { dbg.enterDecision(426);

            int LA426_0 = input.LA(1);

            if ( (LA426_0==LineTerminator) ) {
                alt426=1;
            }


            } finally {dbg.exitDecision(426);}

            switch (alt426) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(950,95);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred238_AS35189); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop426;
            }
        } while (true);
        } finally {dbg.exitSubRule(426);}


        }
    }
    // $ANTLR end synpred238_AS3

    // $ANTLR start synpred264_AS3
    public final void synpred264_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:15: ( Identifier )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:15: Identifier
        {
        dbg.location(976,15);
        match(input,Identifier,FOLLOW_Identifier_in_synpred264_AS35387); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred264_AS3

    // $ANTLR start synpred265_AS3
    public final void synpred265_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:28: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:28: LineTerminator
        {
        dbg.location(976,28);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred265_AS35391); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred265_AS3

    // $ANTLR start synpred266_AS3
    public final void synpred266_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:28: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:28: ( LineTerminator )*
        {
        dbg.location(976,28);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:976:28: ( LineTerminator )*
        try { dbg.enterSubRule(430);

        loop430:
        do {
            int alt430=2;
            try { dbg.enterDecision(430);

            int LA430_0 = input.LA(1);

            if ( (LA430_0==LineTerminator) ) {
                alt430=1;
            }


            } finally {dbg.exitDecision(430);}

            switch (alt430) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(976,28);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred266_AS35391); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop430;
            }
        } while (true);
        } finally {dbg.exitSubRule(430);}


        }
    }
    // $ANTLR end synpred266_AS3

    // $ANTLR start synpred267_AS3
    public final void synpred267_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:12: ( Identifier )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:12: Identifier
        {
        dbg.location(980,12);
        match(input,Identifier,FOLLOW_Identifier_in_synpred267_AS35410); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred267_AS3

    // $ANTLR start synpred268_AS3
    public final void synpred268_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:25: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:25: LineTerminator
        {
        dbg.location(980,25);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred268_AS35414); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred268_AS3

    // $ANTLR start synpred269_AS3
    public final void synpred269_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:25: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:25: ( LineTerminator )*
        {
        dbg.location(980,25);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:980:25: ( LineTerminator )*
        try { dbg.enterSubRule(431);

        loop431:
        do {
            int alt431=2;
            try { dbg.enterDecision(431);

            int LA431_0 = input.LA(1);

            if ( (LA431_0==LineTerminator) ) {
                alt431=1;
            }


            } finally {dbg.exitDecision(431);}

            switch (alt431) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(980,25);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred269_AS35414); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop431;
            }
        } while (true);
        } finally {dbg.exitSubRule(431);}


        }
    }
    // $ANTLR end synpred269_AS3

    // $ANTLR start synpred270_AS3
    public final void synpred270_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:13: ( expression )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:13: expression
        {
        dbg.location(984,13);
        pushFollow(FOLLOW_expression_in_synpred270_AS35433);
        expression();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred270_AS3

    // $ANTLR start synpred271_AS3
    public final void synpred271_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:26: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:26: LineTerminator
        {
        dbg.location(984,26);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred271_AS35437); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred271_AS3

    // $ANTLR start synpred272_AS3
    public final void synpred272_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:26: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:26: ( LineTerminator )*
        {
        dbg.location(984,26);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:984:26: ( LineTerminator )*
        try { dbg.enterSubRule(432);

        loop432:
        do {
            int alt432=2;
            try { dbg.enterDecision(432);

            int LA432_0 = input.LA(1);

            if ( (LA432_0==LineTerminator) ) {
                alt432=1;
            }


            } finally {dbg.exitDecision(432);}

            switch (alt432) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(984,26);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred272_AS35437); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop432;
            }
        } while (true);
        } finally {dbg.exitSubRule(432);}


        }
    }
    // $ANTLR end synpred272_AS3

    // $ANTLR start synpred290_AS3
    public final void synpred290_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:58: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:58: LineTerminator
        {
        dbg.location(1000,58);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred290_AS35571); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred290_AS3

    // $ANTLR start synpred291_AS3
    public final void synpred291_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:74: ( statementList )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1000:74: statementList
        {
        dbg.location(1000,74);
        pushFollow(FOLLOW_statementList_in_synpred291_AS35574);
        statementList();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred291_AS3

    // $ANTLR start synpred293_AS3
    public final void synpred293_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:34: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:34: LineTerminator
        {
        dbg.location(1004,34);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred293_AS35594); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred293_AS3

    // $ANTLR start synpred294_AS3
    public final void synpred294_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:50: ( statementList )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1004:50: statementList
        {
        dbg.location(1004,50);
        pushFollow(FOLLOW_statementList_in_synpred294_AS35597);
        statementList();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred294_AS3

    // $ANTLR start synpred297_AS3
    public final void synpred297_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:24: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:24: LineTerminator
        {
        dbg.location(1012,24);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred297_AS35637); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred297_AS3

    // $ANTLR start synpred298_AS3
    public final void synpred298_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:24: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:24: ( LineTerminator )*
        {
        dbg.location(1012,24);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1012:24: ( LineTerminator )*
        try { dbg.enterSubRule(438);

        loop438:
        do {
            int alt438=2;
            try { dbg.enterDecision(438);

            int LA438_0 = input.LA(1);

            if ( (LA438_0==LineTerminator) ) {
                alt438=1;
            }


            } finally {dbg.exitDecision(438);}

            switch (alt438) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(1012,24);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred298_AS35637); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop438;
            }
        } while (true);
        } finally {dbg.exitSubRule(438);}


        }
    }
    // $ANTLR end synpred298_AS3

    // $ANTLR start synpred301_AS3
    public final void synpred301_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:73: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:73: LineTerminator
        {
        dbg.location(1016,73);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred301_AS35668); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred301_AS3

    // $ANTLR start synpred303_AS3
    public final void synpred303_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:105: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1016:105: LineTerminator
        {
        dbg.location(1016,105);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred303_AS35677); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred303_AS3

    // $ANTLR start synpred316_AS3
    public final void synpred316_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:93: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:93: LineTerminator
        {
        dbg.location(1032,93);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred316_AS35777); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred316_AS3

    // $ANTLR start synpred319_AS3
    public final void synpred319_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:146: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1032:146: LineTerminator
        {
        dbg.location(1032,146);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred319_AS35788); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred319_AS3

    // $ANTLR start synpred321_AS3
    public final void synpred321_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:15: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:15: LineTerminator
        {
        dbg.location(1036,15);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred321_AS35810); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred321_AS3

    // $ANTLR start synpred324_AS3
    public final void synpred324_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:79: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:79: LineTerminator
        {
        dbg.location(1036,79);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred324_AS35821); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred324_AS3

    // $ANTLR start synpred327_AS3
    public final void synpred327_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:132: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1036:132: LineTerminator
        {
        dbg.location(1036,132);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred327_AS35832); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred327_AS3

    // $ANTLR start synpred335_AS3
    public final void synpred335_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:15: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:15: LineTerminator
        {
        dbg.location(1044,15);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred335_AS35892); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred335_AS3

    // $ANTLR start synpred337_AS3
    public final void synpred337_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:48: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1044:48: LineTerminator
        {
        dbg.location(1044,48);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred337_AS35898); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred337_AS3

    // $ANTLR start synpred344_AS3
    public final void synpred344_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1050:35: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1050:35: LineTerminator
        {
        dbg.location(1050,35);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred344_AS35941); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred344_AS3

    // $ANTLR start synpred346_AS3
    public final void synpred346_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1054:4: ( functionDeclaration )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1054:4: functionDeclaration
        {
        dbg.location(1054,4);
        pushFollow(FOLLOW_functionDeclaration_in_synpred346_AS35955);
        functionDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred346_AS3

    // $ANTLR start synpred347_AS3
    public final void synpred347_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:14: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:14: LineTerminator
        {
        dbg.location(1064,14);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred347_AS35978); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred347_AS3

    // $ANTLR start synpred350_AS3
    public final void synpred350_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:65: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1064:65: LineTerminator
        {
        dbg.location(1064,65);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred350_AS35989); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred350_AS3

    // $ANTLR start synpred352_AS3
    public final void synpred352_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:5: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:5: LineTerminator
        {
        dbg.location(1068,5);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred352_AS36010); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred352_AS3

    // $ANTLR start synpred353_AS3
    public final void synpred353_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:36: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1068:36: LineTerminator
        {
        dbg.location(1068,36);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred353_AS36015); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred353_AS3

    // $ANTLR start synpred359_AS3
    public final void synpred359_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:50: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:50: LineTerminator
        {
        dbg.location(1078,50);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred359_AS36061); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred359_AS3

    // $ANTLR start synpred360_AS3
    public final void synpred360_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:50: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:50: ( LineTerminator )*
        {
        dbg.location(1078,50);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1078:50: ( LineTerminator )*
        try { dbg.enterSubRule(456);

        loop456:
        do {
            int alt456=2;
            try { dbg.enterDecision(456);

            int LA456_0 = input.LA(1);

            if ( (LA456_0==LineTerminator) ) {
                alt456=1;
            }


            } finally {dbg.exitDecision(456);}

            switch (alt456) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(1078,50);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred360_AS36061); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop456;
            }
        } while (true);
        } finally {dbg.exitSubRule(456);}


        }
    }
    // $ANTLR end synpred360_AS3

    // $ANTLR start synpred364_AS3
    public final void synpred364_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1082:53: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1082:53: LineTerminator
        {
        dbg.location(1082,53);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred364_AS36092); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred364_AS3

    // $ANTLR start synpred368_AS3
    public final void synpred368_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:67: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:67: LineTerminator
        {
        dbg.location(1086,67);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred368_AS36119); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred368_AS3

    // $ANTLR start synpred370_AS3
    public final void synpred370_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:96: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:96: LineTerminator
        {
        dbg.location(1086,96);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred370_AS36125); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred370_AS3

    // $ANTLR start synpred373_AS3
    public final void synpred373_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:158: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1086:158: LineTerminator
        {
        dbg.location(1086,158);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred373_AS36136); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred373_AS3

    // $ANTLR start synpred378_AS3
    public final void synpred378_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1090:53: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1090:53: LineTerminator
        {
        dbg.location(1090,53);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred378_AS36170); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred378_AS3

    // $ANTLR start synpred382_AS3
    public final void synpred382_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:72: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:72: LineTerminator
        {
        dbg.location(1094,72);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred382_AS36198); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred382_AS3

    // $ANTLR start synpred385_AS3
    public final void synpred385_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:121: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1094:121: LineTerminator
        {
        dbg.location(1094,121);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred385_AS36209); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred385_AS3

    // $ANTLR start synpred392_AS3
    public final void synpred392_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:5: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:5: LineTerminator
        {
        dbg.location(1114,5);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred392_AS36283); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred392_AS3

    // $ANTLR start synpred393_AS3
    public final void synpred393_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:34: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1114:34: LineTerminator
        {
        dbg.location(1114,34);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred393_AS36288); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred393_AS3

    // $ANTLR start synpred395_AS3
    public final void synpred395_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:4: ( 'override' )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:4: 'override'
        {
        dbg.location(1118,4);
        match(input,125,FOLLOW_125_in_synpred395_AS36302); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred395_AS3

    // $ANTLR start synpred396_AS3
    public final void synpred396_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:16: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:16: LineTerminator
        {
        dbg.location(1118,16);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred396_AS36305); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred396_AS3

    // $ANTLR start synpred398_AS3
    public final void synpred398_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:43: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:43: LineTerminator
        {
        dbg.location(1118,43);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred398_AS36311); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred398_AS3

    // $ANTLR start synpred401_AS3
    public final void synpred401_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:4: ( ( 'override' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'override' )? ( LineTerminator )* functionDeclaration )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:4: ( 'override' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'override' )? ( LineTerminator )* functionDeclaration
        {
        dbg.location(1118,4);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:4: ( 'override' )?
        int alt461=2;
        try { dbg.enterSubRule(461);
        try { dbg.enterDecision(461);

        int LA461_0 = input.LA(1);

        if ( (LA461_0==125) ) {
            int LA461_1 = input.LA(2);

            if ( (synpred395_AS3()) ) {
                alt461=1;
            }
        }
        } finally {dbg.exitDecision(461);}

        switch (alt461) {
            case 1 :
                dbg.enterAlt(1);

                // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'override'
                {
                dbg.location(1118,4);
                match(input,125,FOLLOW_125_in_synpred401_AS36302); if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(461);}

        dbg.location(1118,16);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:16: ( LineTerminator )*
        try { dbg.enterSubRule(462);

        loop462:
        do {
            int alt462=2;
            try { dbg.enterDecision(462);

            int LA462_0 = input.LA(1);

            if ( (LA462_0==LineTerminator) ) {
                int LA462_2 = input.LA(2);

                if ( (synpred396_AS3()) ) {
                    alt462=1;
                }


            }


            } finally {dbg.exitDecision(462);}

            switch (alt462) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(1118,16);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred401_AS36305); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop462;
            }
        } while (true);
        } finally {dbg.exitSubRule(462);}

        dbg.location(1118,32);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:32: ( namespace )?
        int alt463=2;
        try { dbg.enterSubRule(463);
        try { dbg.enterDecision(463);

        int LA463_0 = input.LA(1);

        if ( (LA463_0==Identifier||(LA463_0>=119 && LA463_0<=120)||(LA463_0>=130 && LA463_0<=131)) ) {
            alt463=1;
        }
        } finally {dbg.exitDecision(463);}

        switch (alt463) {
            case 1 :
                dbg.enterAlt(1);

                // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: namespace
                {
                dbg.location(1118,32);
                pushFollow(FOLLOW_namespace_in_synpred401_AS36308);
                namespace();

                state._fsp--;
                if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(463);}

        dbg.location(1118,43);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:43: ( LineTerminator )*
        try { dbg.enterSubRule(464);

        loop464:
        do {
            int alt464=2;
            try { dbg.enterDecision(464);

            int LA464_0 = input.LA(1);

            if ( (LA464_0==LineTerminator) ) {
                int LA464_2 = input.LA(2);

                if ( (synpred398_AS3()) ) {
                    alt464=1;
                }


            }


            } finally {dbg.exitDecision(464);}

            switch (alt464) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(1118,43);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred401_AS36311); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop464;
            }
        } while (true);
        } finally {dbg.exitSubRule(464);}

        dbg.location(1118,59);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:59: ( 'override' )?
        int alt465=2;
        try { dbg.enterSubRule(465);
        try { dbg.enterDecision(465);

        int LA465_0 = input.LA(1);

        if ( (LA465_0==125) ) {
            alt465=1;
        }
        } finally {dbg.exitDecision(465);}

        switch (alt465) {
            case 1 :
                dbg.enterAlt(1);

                // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: 'override'
                {
                dbg.location(1118,59);
                match(input,125,FOLLOW_125_in_synpred401_AS36314); if (state.failed) return ;

                }
                break;

        }
        } finally {dbg.exitSubRule(465);}

        dbg.location(1118,71);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1118:71: ( LineTerminator )*
        try { dbg.enterSubRule(466);

        loop466:
        do {
            int alt466=2;
            try { dbg.enterDecision(466);

            int LA466_0 = input.LA(1);

            if ( (LA466_0==LineTerminator) ) {
                alt466=1;
            }


            } finally {dbg.exitDecision(466);}

            switch (alt466) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(1118,71);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred401_AS36317); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop466;
            }
        } while (true);
        } finally {dbg.exitSubRule(466);}

        dbg.location(1118,87);
        pushFollow(FOLLOW_functionDeclaration_in_synpred401_AS36320);
        functionDeclaration();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred401_AS3

    // $ANTLR start synpred402_AS3
    public final void synpred402_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:4: ( 'static' )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:4: 'static'
        {
        dbg.location(1119,4);
        match(input,126,FOLLOW_126_in_synpred402_AS36325); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred402_AS3

    // $ANTLR start synpred403_AS3
    public final void synpred403_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:14: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:14: LineTerminator
        {
        dbg.location(1119,14);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred403_AS36328); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred403_AS3

    // $ANTLR start synpred405_AS3
    public final void synpred405_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:41: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1119:41: LineTerminator
        {
        dbg.location(1119,41);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred405_AS36334); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred405_AS3

    // $ANTLR start synpred409_AS3
    public final void synpred409_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1123:4: ( classMember )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1123:4: classMember
        {
        dbg.location(1123,4);
        pushFollow(FOLLOW_classMember_in_synpred409_AS36362);
        classMember();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred409_AS3

    // $ANTLR start synpred411_AS3
    public final void synpred411_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1128:38: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1128:38: LineTerminator
        {
        dbg.location(1128,38);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred411_AS36384); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred411_AS3

    // $ANTLR start synpred413_AS3
    public final void synpred413_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1136:16: ( '.' Identifier )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1136:16: '.' Identifier
        {
        dbg.location(1136,16);
        match(input,45,FOLLOW_45_in_synpred413_AS36414); if (state.failed) return ;
        dbg.location(1136,20);
        match(input,Identifier,FOLLOW_Identifier_in_synpred413_AS36416); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred413_AS3

    // $ANTLR start synpred417_AS3
    public final void synpred417_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:66: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:66: LineTerminator
        {
        dbg.location(1144,66);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred417_AS36461); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred417_AS3

    // $ANTLR start synpred418_AS3
    public final void synpred418_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:66: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:66: ( LineTerminator )*
        {
        dbg.location(1144,66);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1144:66: ( LineTerminator )*
        try { dbg.enterSubRule(469);

        loop469:
        do {
            int alt469=2;
            try { dbg.enterDecision(469);

            int LA469_0 = input.LA(1);

            if ( (LA469_0==LineTerminator) ) {
                alt469=1;
            }


            } finally {dbg.exitDecision(469);}

            switch (alt469) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(1144,66);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred418_AS36461); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop469;
            }
        } while (true);
        } finally {dbg.exitSubRule(469);}


        }
    }
    // $ANTLR end synpred418_AS3

    // $ANTLR start synpred420_AS3
    public final void synpred420_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1148:35: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1148:35: LineTerminator
        {
        dbg.location(1148,35);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred420_AS36485); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred420_AS3

    // $ANTLR start synpred424_AS3
    public final void synpred424_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:45: ( LineTerminator )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:45: LineTerminator
        {
        dbg.location(1152,45);
        match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred424_AS36514); if (state.failed) return ;

        }
    }
    // $ANTLR end synpred424_AS3

    // $ANTLR start synpred425_AS3
    public final void synpred425_AS3_fragment() throws RecognitionException {   
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:45: ( ( LineTerminator )* )
        dbg.enterAlt(1);

        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:45: ( LineTerminator )*
        {
        dbg.location(1152,45);
        // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:1152:45: ( LineTerminator )*
        try { dbg.enterSubRule(470);

        loop470:
        do {
            int alt470=2;
            try { dbg.enterDecision(470);

            int LA470_0 = input.LA(1);

            if ( (LA470_0==LineTerminator) ) {
                alt470=1;
            }


            } finally {dbg.exitDecision(470);}

            switch (alt470) {
        	case 1 :
        	    dbg.enterAlt(1);

        	    // ./src/com/joa_ebert/as3v/language/as3/antlr/AS3.g:0:0: LineTerminator
        	    {
        	    dbg.location(1152,45);
        	    match(input,LineTerminator,FOLLOW_LineTerminator_in_synpred425_AS36514); if (state.failed) return ;

        	    }
        	    break;

        	default :
        	    break loop470;
            }
        } while (true);
        } finally {dbg.exitSubRule(470);}


        }
    }
    // $ANTLR end synpred425_AS3

    // Delegated rules

    public final boolean synpred316_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred316_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred212_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred212_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred368_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred368_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred392_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred392_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred359_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred359_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred156_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred156_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred230_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred230_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred205_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred205_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred385_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred385_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred61_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred61_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred370_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred370_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred95_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred95_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred238_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred238_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred267_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred267_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred182_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred182_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred270_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred270_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred271_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred271_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred401_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred401_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred409_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred409_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred344_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred344_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred418_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred418_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred403_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred403_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred200_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred200_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred265_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred265_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred233_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred233_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred337_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred337_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred364_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred364_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred301_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred301_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred269_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred269_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred268_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred268_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred373_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred373_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred204_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred204_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred40_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred40_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred347_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred347_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred350_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred350_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred417_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred417_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred353_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred353_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred196_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred196_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred425_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred425_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred266_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred266_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred321_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred321_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred12_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred12_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred424_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred424_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred420_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred420_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred272_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred272_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred319_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred319_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred62_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred62_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred81_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred81_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred303_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred303_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred298_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred298_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred411_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred411_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred2_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred2_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred405_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred405_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred60_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred60_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred398_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred398_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred179_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred179_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred324_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred324_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred11_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred11_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred297_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred297_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred378_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred378_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred222_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred222_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred197_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred197_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred352_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred352_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred218_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred218_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred294_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred294_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred402_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred402_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred413_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred413_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred291_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred291_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred346_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred346_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred237_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred237_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred360_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred360_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred214_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred214_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred290_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred290_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred293_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred293_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred335_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred335_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred327_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred327_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred159_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred159_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred42_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred42_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred264_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred264_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred216_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred216_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred223_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred223_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred382_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred382_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred393_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred393_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred46_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred46_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred395_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred395_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred396_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred396_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred189_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred189_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred18_AS3() {
        state.backtracking++;
        dbg.beginBacktrack(state.backtracking);
        int start = input.mark();
        try {
            synpred18_AS3_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        dbg.endBacktrack(state.backtracking, success);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA3 dfa3 = new DFA3(this);
    protected DFA7 dfa7 = new DFA7(this);
    protected DFA13 dfa13 = new DFA13(this);
    protected DFA12 dfa12 = new DFA12(this);
    protected DFA18 dfa18 = new DFA18(this);
    protected DFA27 dfa27 = new DFA27(this);
    protected DFA30 dfa30 = new DFA30(this);
    protected DFA33 dfa33 = new DFA33(this);
    protected DFA44 dfa44 = new DFA44(this);
    protected DFA43 dfa43 = new DFA43(this);
    protected DFA46 dfa46 = new DFA46(this);
    protected DFA47 dfa47 = new DFA47(this);
    protected DFA51 dfa51 = new DFA51(this);
    protected DFA54 dfa54 = new DFA54(this);
    protected DFA57 dfa57 = new DFA57(this);
    protected DFA60 dfa60 = new DFA60(this);
    protected DFA63 dfa63 = new DFA63(this);
    protected DFA66 dfa66 = new DFA66(this);
    protected DFA69 dfa69 = new DFA69(this);
    protected DFA72 dfa72 = new DFA72(this);
    protected DFA75 dfa75 = new DFA75(this);
    protected DFA78 dfa78 = new DFA78(this);
    protected DFA81 dfa81 = new DFA81(this);
    protected DFA84 dfa84 = new DFA84(this);
    protected DFA87 dfa87 = new DFA87(this);
    protected DFA90 dfa90 = new DFA90(this);
    protected DFA93 dfa93 = new DFA93(this);
    protected DFA96 dfa96 = new DFA96(this);
    protected DFA99 dfa99 = new DFA99(this);
    protected DFA104 dfa104 = new DFA104(this);
    protected DFA109 dfa109 = new DFA109(this);
    protected DFA112 dfa112 = new DFA112(this);
    protected DFA115 dfa115 = new DFA115(this);
    protected DFA118 dfa118 = new DFA118(this);
    protected DFA121 dfa121 = new DFA121(this);
    protected DFA122 dfa122 = new DFA122(this);
    protected DFA128 dfa128 = new DFA128(this);
    protected DFA134 dfa134 = new DFA134(this);
    protected DFA137 dfa137 = new DFA137(this);
    protected DFA169 dfa169 = new DFA169(this);
    protected DFA172 dfa172 = new DFA172(this);
    protected DFA175 dfa175 = new DFA175(this);
    protected DFA194 dfa194 = new DFA194(this);
    protected DFA206 dfa206 = new DFA206(this);
    protected DFA210 dfa210 = new DFA210(this);
    protected DFA209 dfa209 = new DFA209(this);
    protected DFA256 dfa256 = new DFA256(this);
    protected DFA255 dfa255 = new DFA255(this);
    protected DFA264 dfa264 = new DFA264(this);
    protected DFA267 dfa267 = new DFA267(this);
    protected DFA268 dfa268 = new DFA268(this);
    protected DFA276 dfa276 = new DFA276(this);
    protected DFA277 dfa277 = new DFA277(this);
    protected DFA310 dfa310 = new DFA310(this);
    protected DFA313 dfa313 = new DFA313(this);
    protected DFA327 dfa327 = new DFA327(this);
    protected DFA328 dfa328 = new DFA328(this);
    protected DFA331 dfa331 = new DFA331(this);
    static final String DFA3_eotS =
        "\7\uffff";
    static final String DFA3_eofS =
        "\2\2\5\uffff";
    static final String DFA3_minS =
        "\2\4\1\uffff\1\4\2\uffff\1\4";
    static final String DFA3_maxS =
        "\2\172\1\uffff\1\172\2\uffff\1\172";
    static final String DFA3_acceptS =
        "\2\uffff\1\3\1\uffff\1\1\1\2\1\uffff";
    static final String DFA3_specialS =
        "\7\uffff}>";
    static final String[] DFA3_transitionS = {
            "\1\1\161\uffff\1\3\2\uffff\1\4\1\5",
            "\1\1\164\uffff\1\4\1\5",
            "",
            "\1\6\164\uffff\1\4\1\5",
            "",
            "",
            "\1\6\164\uffff\1\4\1\5"
    };

    static final short[] DFA3_eot = DFA.unpackEncodedString(DFA3_eotS);
    static final short[] DFA3_eof = DFA.unpackEncodedString(DFA3_eofS);
    static final char[] DFA3_min = DFA.unpackEncodedStringToUnsignedChars(DFA3_minS);
    static final char[] DFA3_max = DFA.unpackEncodedStringToUnsignedChars(DFA3_maxS);
    static final short[] DFA3_accept = DFA.unpackEncodedString(DFA3_acceptS);
    static final short[] DFA3_special = DFA.unpackEncodedString(DFA3_specialS);
    static final short[][] DFA3_transition;

    static {
        int numStates = DFA3_transitionS.length;
        DFA3_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA3_transition[i] = DFA.unpackEncodedString(DFA3_transitionS[i]);
        }
    }

    class DFA3 extends DFA {

        public DFA3(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 3;
            this.eot = DFA3_eot;
            this.eof = DFA3_eof;
            this.min = DFA3_min;
            this.max = DFA3_max;
            this.accept = DFA3_accept;
            this.special = DFA3_special;
            this.transition = DFA3_transition;
        }
        public String getDescription() {
            return "()* loopback of 36:55: ( normalClassDeclaration | normalInterfaceDeclaration )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA7_eotS =
        "\12\uffff";
    static final String DFA7_eofS =
        "\12\uffff";
    static final String DFA7_minS =
        "\1\13\2\uffff\1\0\6\uffff";
    static final String DFA7_maxS =
        "\1\51\2\uffff\1\0\6\uffff";
    static final String DFA7_acceptS =
        "\1\uffff\1\1\1\2\1\uffff\1\5\1\6\1\7\1\10\1\3\1\4";
    static final String DFA7_specialS =
        "\3\uffff\1\0\6\uffff}>";
    static final String[] DFA7_transitionS = {
            "\1\3\5\uffff\4\4\15\uffff\1\1\1\2\1\7\1\uffff\1\5\2\uffff\1"+
            "\6",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
    static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
    static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
    static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
    static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
    static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
    static final short[][] DFA7_transition;

    static {
        int numStates = DFA7_transitionS.length;
        DFA7_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
        }
    }

    class DFA7 extends DFA {

        public DFA7(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 7;
            this.eot = DFA7_eot;
            this.eof = DFA7_eof;
            this.min = DFA7_min;
            this.max = DFA7_max;
            this.accept = DFA7_accept;
            this.special = DFA7_special;
            this.transition = DFA7_transition;
        }
        public String getDescription() {
            return "690:1: primaryExpression : ( 'this' | 'super' | Identifier | qualifiedName | literal | arrayLiteral | objectLiteral | '(' ( LineTerminator )* expression ( LineTerminator )* ')' );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA7_3 = input.LA(1);

                         
                        int index7_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred11_AS3()) ) {s = 8;}

                        else if ( (synpred12_AS3()) ) {s = 9;}

                         
                        input.seek(index7_3);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 7, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA13_eotS =
        "\4\uffff";
    static final String DFA13_eofS =
        "\4\uffff";
    static final String DFA13_minS =
        "\2\4\2\uffff";
    static final String DFA13_maxS =
        "\2\50\2\uffff";
    static final String DFA13_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA13_specialS =
        "\4\uffff}>";
    static final String[] DFA13_transitionS = {
            "\1\1\42\uffff\1\3\1\2",
            "\1\1\42\uffff\1\3\1\2",
            "",
            ""
    };

    static final short[] DFA13_eot = DFA.unpackEncodedString(DFA13_eotS);
    static final short[] DFA13_eof = DFA.unpackEncodedString(DFA13_eofS);
    static final char[] DFA13_min = DFA.unpackEncodedStringToUnsignedChars(DFA13_minS);
    static final char[] DFA13_max = DFA.unpackEncodedStringToUnsignedChars(DFA13_maxS);
    static final short[] DFA13_accept = DFA.unpackEncodedString(DFA13_acceptS);
    static final short[] DFA13_special = DFA.unpackEncodedString(DFA13_specialS);
    static final short[][] DFA13_transition;

    static {
        int numStates = DFA13_transitionS.length;
        DFA13_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA13_transition[i] = DFA.unpackEncodedString(DFA13_transitionS[i]);
        }
    }

    class DFA13 extends DFA {

        public DFA13(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 13;
            this.eot = DFA13_eot;
            this.eof = DFA13_eof;
            this.min = DFA13_min;
            this.max = DFA13_max;
            this.accept = DFA13_accept;
            this.special = DFA13_special;
            this.transition = DFA13_transition;
        }
        public String getDescription() {
            return "()* loopback of 702:46: ( ( LineTerminator )* ',' ( ( LineTerminator )* assignmentExpression )? )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA12_eotS =
        "\4\uffff";
    static final String DFA12_eofS =
        "\4\uffff";
    static final String DFA12_minS =
        "\2\4\2\uffff";
    static final String DFA12_maxS =
        "\2\157\2\uffff";
    static final String DFA12_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA12_specialS =
        "\4\uffff}>";
    static final String[] DFA12_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\2\3\1"+
            "\2\2\uffff\1\2\2\uffff\12\2\66\uffff\1\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\2\3"+
            "\1\2\2\uffff\1\2\2\uffff\12\2\66\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA12_eot = DFA.unpackEncodedString(DFA12_eotS);
    static final short[] DFA12_eof = DFA.unpackEncodedString(DFA12_eofS);
    static final char[] DFA12_min = DFA.unpackEncodedStringToUnsignedChars(DFA12_minS);
    static final char[] DFA12_max = DFA.unpackEncodedStringToUnsignedChars(DFA12_maxS);
    static final short[] DFA12_accept = DFA.unpackEncodedString(DFA12_acceptS);
    static final short[] DFA12_special = DFA.unpackEncodedString(DFA12_specialS);
    static final short[][] DFA12_transition;

    static {
        int numStates = DFA12_transitionS.length;
        DFA12_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA12_transition[i] = DFA.unpackEncodedString(DFA12_transitionS[i]);
        }
    }

    class DFA12 extends DFA {

        public DFA12(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 12;
            this.eot = DFA12_eot;
            this.eof = DFA12_eof;
            this.min = DFA12_min;
            this.max = DFA12_max;
            this.accept = DFA12_accept;
            this.special = DFA12_special;
            this.transition = DFA12_transition;
        }
        public String getDescription() {
            return "702:67: ( ( LineTerminator )* assignmentExpression )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA18_eotS =
        "\4\uffff";
    static final String DFA18_eofS =
        "\4\uffff";
    static final String DFA18_minS =
        "\2\4\2\uffff";
    static final String DFA18_maxS =
        "\2\52\2\uffff";
    static final String DFA18_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA18_specialS =
        "\4\uffff}>";
    static final String[] DFA18_transitionS = {
            "\1\1\42\uffff\1\3\2\uffff\1\2",
            "\1\1\42\uffff\1\3\2\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA18_eot = DFA.unpackEncodedString(DFA18_eotS);
    static final short[] DFA18_eof = DFA.unpackEncodedString(DFA18_eofS);
    static final char[] DFA18_min = DFA.unpackEncodedStringToUnsignedChars(DFA18_minS);
    static final char[] DFA18_max = DFA.unpackEncodedStringToUnsignedChars(DFA18_maxS);
    static final short[] DFA18_accept = DFA.unpackEncodedString(DFA18_acceptS);
    static final short[] DFA18_special = DFA.unpackEncodedString(DFA18_specialS);
    static final short[][] DFA18_transition;

    static {
        int numStates = DFA18_transitionS.length;
        DFA18_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA18_transition[i] = DFA.unpackEncodedString(DFA18_transitionS[i]);
        }
    }

    class DFA18 extends DFA {

        public DFA18(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 18;
            this.eot = DFA18_eot;
            this.eof = DFA18_eof;
            this.min = DFA18_min;
            this.max = DFA18_max;
            this.accept = DFA18_accept;
            this.special = DFA18_special;
            this.transition = DFA18_transition;
        }
        public String getDescription() {
            return "()* loopback of 706:46: ( ( LineTerminator )* ',' ( LineTerminator )* propertyNameAndValue )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA27_eotS =
        "\74\uffff";
    static final String DFA27_eofS =
        "\1\2\73\uffff";
    static final String DFA27_minS =
        "\1\4\1\0\36\uffff\1\0\33\uffff";
    static final String DFA27_maxS =
        "\1\u0083\1\0\36\uffff\1\0\33\uffff";
    static final String DFA27_acceptS =
        "\2\uffff\1\2\70\uffff\1\1";
    static final String DFA27_specialS =
        "\1\uffff\1\0\36\uffff\1\1\33\uffff}>";
    static final String[] DFA27_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\4\2\1\40\6\2\1\73\1\uffff"+
            "\76\2\2\uffff\1\2\4\uffff\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff"+
            "\3\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA27_eot = DFA.unpackEncodedString(DFA27_eotS);
    static final short[] DFA27_eof = DFA.unpackEncodedString(DFA27_eofS);
    static final char[] DFA27_min = DFA.unpackEncodedStringToUnsignedChars(DFA27_minS);
    static final char[] DFA27_max = DFA.unpackEncodedStringToUnsignedChars(DFA27_maxS);
    static final short[] DFA27_accept = DFA.unpackEncodedString(DFA27_acceptS);
    static final short[] DFA27_special = DFA.unpackEncodedString(DFA27_specialS);
    static final short[][] DFA27_transition;

    static {
        int numStates = DFA27_transitionS.length;
        DFA27_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA27_transition[i] = DFA.unpackEncodedString(DFA27_transitionS[i]);
        }
    }

    class DFA27 extends DFA {

        public DFA27(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 27;
            this.eot = DFA27_eot;
            this.eof = DFA27_eof;
            this.min = DFA27_min;
            this.max = DFA27_max;
            this.accept = DFA27_accept;
            this.special = DFA27_special;
            this.transition = DFA27_transition;
        }
        public String getDescription() {
            return "()* loopback of 720:115: ( ( LineTerminator )* memberExpressionSuffix )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA27_1 = input.LA(1);

                         
                        int index27_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred40_AS3()) ) {s = 59;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index27_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA27_32 = input.LA(1);

                         
                        int index27_32 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred40_AS3()) ) {s = 59;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index27_32);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 27, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA30_eotS =
        "\13\uffff";
    static final String DFA30_eofS =
        "\13\uffff";
    static final String DFA30_minS =
        "\1\13\10\uffff\1\0\1\uffff";
    static final String DFA30_maxS =
        "\1\157\10\uffff\1\0\1\uffff";
    static final String DFA30_acceptS =
        "\1\uffff\1\1\10\uffff\1\2";
    static final String DFA30_specialS =
        "\11\uffff\1\0\1\uffff}>";
    static final String[] DFA30_transitionS = {
            "\1\1\5\uffff\4\1\15\uffff\3\1\1\uffff\1\1\2\uffff\1\1\2\uffff"+
            "\1\11\102\uffff\1\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            ""
    };

    static final short[] DFA30_eot = DFA.unpackEncodedString(DFA30_eotS);
    static final short[] DFA30_eof = DFA.unpackEncodedString(DFA30_eofS);
    static final char[] DFA30_min = DFA.unpackEncodedStringToUnsignedChars(DFA30_minS);
    static final char[] DFA30_max = DFA.unpackEncodedStringToUnsignedChars(DFA30_maxS);
    static final short[] DFA30_accept = DFA.unpackEncodedString(DFA30_acceptS);
    static final short[] DFA30_special = DFA.unpackEncodedString(DFA30_specialS);
    static final short[][] DFA30_transition;

    static {
        int numStates = DFA30_transitionS.length;
        DFA30_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA30_transition[i] = DFA.unpackEncodedString(DFA30_transitionS[i]);
        }
    }

    class DFA30 extends DFA {

        public DFA30(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 30;
            this.eot = DFA30_eot;
            this.eof = DFA30_eof;
            this.min = DFA30_min;
            this.max = DFA30_max;
            this.accept = DFA30_accept;
            this.special = DFA30_special;
            this.transition = DFA30_transition;
        }
        public String getDescription() {
            return "728:1: newExpression : ( memberExpression | 'new' ( LineTerminator )* newExpression );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA30_9 = input.LA(1);

                         
                        int index30_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred42_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 10;}

                         
                        input.seek(index30_9);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 30, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA33_eotS =
        "\74\uffff";
    static final String DFA33_eofS =
        "\1\1\73\uffff";
    static final String DFA33_minS =
        "\1\4\2\uffff\1\0\33\uffff\2\0\33\uffff";
    static final String DFA33_maxS =
        "\1\u0083\2\uffff\1\0\33\uffff\2\0\33\uffff";
    static final String DFA33_acceptS =
        "\1\uffff\1\2\71\uffff\1\1";
    static final String DFA33_specialS =
        "\3\uffff\1\0\33\uffff\1\1\1\2\33\uffff}>";
    static final String[] DFA33_transitionS = {
            "\1\3\6\uffff\1\1\5\uffff\4\1\15\uffff\2\1\1\40\1\1\1\37\6\1"+
            "\1\73\1\uffff\76\1\2\uffff\1\1\4\uffff\1\1\1\uffff\3\1\4\uffff"+
            "\3\1\1\uffff\3\1",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA33_eot = DFA.unpackEncodedString(DFA33_eotS);
    static final short[] DFA33_eof = DFA.unpackEncodedString(DFA33_eofS);
    static final char[] DFA33_min = DFA.unpackEncodedStringToUnsignedChars(DFA33_minS);
    static final char[] DFA33_max = DFA.unpackEncodedStringToUnsignedChars(DFA33_maxS);
    static final short[] DFA33_accept = DFA.unpackEncodedString(DFA33_acceptS);
    static final short[] DFA33_special = DFA.unpackEncodedString(DFA33_specialS);
    static final short[][] DFA33_transition;

    static {
        int numStates = DFA33_transitionS.length;
        DFA33_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA33_transition[i] = DFA.unpackEncodedString(DFA33_transitionS[i]);
        }
    }

    class DFA33 extends DFA {

        public DFA33(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 33;
            this.eot = DFA33_eot;
            this.eof = DFA33_eof;
            this.min = DFA33_min;
            this.max = DFA33_max;
            this.accept = DFA33_accept;
            this.special = DFA33_special;
            this.transition = DFA33_transition;
        }
        public String getDescription() {
            return "()* loopback of 734:50: ( ( LineTerminator )* callExpressionSuffix )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA33_3 = input.LA(1);

                         
                        int index33_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred46_AS3()) ) {s = 59;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index33_3);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA33_31 = input.LA(1);

                         
                        int index33_31 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred46_AS3()) ) {s = 59;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index33_31);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA33_32 = input.LA(1);

                         
                        int index33_32 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred46_AS3()) ) {s = 59;}

                        else if ( (true) ) {s = 1;}

                         
                        input.seek(index33_32);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 33, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA44_eotS =
        "\4\uffff";
    static final String DFA44_eofS =
        "\4\uffff";
    static final String DFA44_minS =
        "\2\4\2\uffff";
    static final String DFA44_maxS =
        "\2\157\2\uffff";
    static final String DFA44_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA44_specialS =
        "\4\uffff}>";
    static final String[] DFA44_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\3\1\2\2\uffff\1"+
            "\2\2\uffff\1\2\2\uffff\12\2\66\uffff\1\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\3\1\2\2\uffff"+
            "\1\2\2\uffff\1\2\2\uffff\12\2\66\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA44_eot = DFA.unpackEncodedString(DFA44_eotS);
    static final short[] DFA44_eof = DFA.unpackEncodedString(DFA44_eofS);
    static final char[] DFA44_min = DFA.unpackEncodedStringToUnsignedChars(DFA44_minS);
    static final char[] DFA44_max = DFA.unpackEncodedStringToUnsignedChars(DFA44_maxS);
    static final short[] DFA44_accept = DFA.unpackEncodedString(DFA44_acceptS);
    static final short[] DFA44_special = DFA.unpackEncodedString(DFA44_specialS);
    static final short[][] DFA44_transition;

    static {
        int numStates = DFA44_transitionS.length;
        DFA44_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA44_transition[i] = DFA.unpackEncodedString(DFA44_transitionS[i]);
        }
    }

    class DFA44 extends DFA {

        public DFA44(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 44;
            this.eot = DFA44_eot;
            this.eof = DFA44_eof;
            this.min = DFA44_min;
            this.max = DFA44_max;
            this.accept = DFA44_accept;
            this.special = DFA44_special;
            this.transition = DFA44_transition;
        }
        public String getDescription() {
            return "752:8: ( ( LineTerminator )* assignmentExpression ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )* )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA43_eotS =
        "\4\uffff";
    static final String DFA43_eofS =
        "\4\uffff";
    static final String DFA43_minS =
        "\2\4\2\uffff";
    static final String DFA43_maxS =
        "\2\47\2\uffff";
    static final String DFA43_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA43_specialS =
        "\4\uffff}>";
    static final String[] DFA43_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\3",
            "\1\1\40\uffff\1\2\1\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA43_eot = DFA.unpackEncodedString(DFA43_eotS);
    static final short[] DFA43_eof = DFA.unpackEncodedString(DFA43_eofS);
    static final char[] DFA43_min = DFA.unpackEncodedStringToUnsignedChars(DFA43_minS);
    static final char[] DFA43_max = DFA.unpackEncodedStringToUnsignedChars(DFA43_maxS);
    static final short[] DFA43_accept = DFA.unpackEncodedString(DFA43_acceptS);
    static final short[] DFA43_special = DFA.unpackEncodedString(DFA43_specialS);
    static final short[][] DFA43_transition;

    static {
        int numStates = DFA43_transitionS.length;
        DFA43_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA43_transition[i] = DFA.unpackEncodedString(DFA43_transitionS[i]);
        }
    }

    class DFA43 extends DFA {

        public DFA43(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 43;
            this.eot = DFA43_eot;
            this.eof = DFA43_eof;
            this.min = DFA43_min;
            this.max = DFA43_max;
            this.accept = DFA43_accept;
            this.special = DFA43_special;
            this.transition = DFA43_transition;
        }
        public String getDescription() {
            return "()* loopback of 752:46: ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA46_eotS =
        "\14\uffff";
    static final String DFA46_eofS =
        "\14\uffff";
    static final String DFA46_minS =
        "\1\13\11\0\2\uffff";
    static final String DFA46_maxS =
        "\1\157\11\0\2\uffff";
    static final String DFA46_acceptS =
        "\12\uffff\1\1\1\2";
    static final String DFA46_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff}>";
    static final String[] DFA46_transitionS = {
            "\1\3\5\uffff\4\4\15\uffff\1\1\1\2\1\7\1\uffff\1\5\2\uffff\1"+
            "\6\2\uffff\1\11\102\uffff\1\10",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA46_eot = DFA.unpackEncodedString(DFA46_eotS);
    static final short[] DFA46_eof = DFA.unpackEncodedString(DFA46_eofS);
    static final char[] DFA46_min = DFA.unpackEncodedStringToUnsignedChars(DFA46_minS);
    static final char[] DFA46_max = DFA.unpackEncodedStringToUnsignedChars(DFA46_maxS);
    static final short[] DFA46_accept = DFA.unpackEncodedString(DFA46_acceptS);
    static final short[] DFA46_special = DFA.unpackEncodedString(DFA46_specialS);
    static final short[][] DFA46_transition;

    static {
        int numStates = DFA46_transitionS.length;
        DFA46_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA46_transition[i] = DFA.unpackEncodedString(DFA46_transitionS[i]);
        }
    }

    class DFA46 extends DFA {

        public DFA46(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 46;
            this.eot = DFA46_eot;
            this.eof = DFA46_eof;
            this.min = DFA46_min;
            this.max = DFA46_max;
            this.accept = DFA46_accept;
            this.special = DFA46_special;
            this.transition = DFA46_transition;
        }
        public String getDescription() {
            return "755:1: leftHandSideExpression : ( callExpression | newExpression );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA46_1 = input.LA(1);

                         
                        int index46_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA46_2 = input.LA(1);

                         
                        int index46_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA46_3 = input.LA(1);

                         
                        int index46_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA46_4 = input.LA(1);

                         
                        int index46_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA46_5 = input.LA(1);

                         
                        int index46_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA46_6 = input.LA(1);

                         
                        int index46_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA46_7 = input.LA(1);

                         
                        int index46_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA46_8 = input.LA(1);

                         
                        int index46_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA46_9 = input.LA(1);

                         
                        int index46_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred60_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index46_9);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 46, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA47_eotS =
        "\15\uffff";
    static final String DFA47_eofS =
        "\15\uffff";
    static final String DFA47_minS =
        "\1\13\11\0\3\uffff";
    static final String DFA47_maxS =
        "\1\157\11\0\3\uffff";
    static final String DFA47_acceptS =
        "\12\uffff\1\1\1\2\1\3";
    static final String DFA47_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\3\uffff}>";
    static final String[] DFA47_transitionS = {
            "\1\3\5\uffff\4\4\15\uffff\1\1\1\2\1\7\1\uffff\1\5\2\uffff\1"+
            "\6\2\uffff\1\11\102\uffff\1\10",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] DFA47_eot = DFA.unpackEncodedString(DFA47_eotS);
    static final short[] DFA47_eof = DFA.unpackEncodedString(DFA47_eofS);
    static final char[] DFA47_min = DFA.unpackEncodedStringToUnsignedChars(DFA47_minS);
    static final char[] DFA47_max = DFA.unpackEncodedStringToUnsignedChars(DFA47_maxS);
    static final short[] DFA47_accept = DFA.unpackEncodedString(DFA47_acceptS);
    static final short[] DFA47_special = DFA.unpackEncodedString(DFA47_specialS);
    static final short[][] DFA47_transition;

    static {
        int numStates = DFA47_transitionS.length;
        DFA47_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA47_transition[i] = DFA.unpackEncodedString(DFA47_transitionS[i]);
        }
    }

    class DFA47 extends DFA {

        public DFA47(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 47;
            this.eot = DFA47_eot;
            this.eof = DFA47_eof;
            this.min = DFA47_min;
            this.max = DFA47_max;
            this.accept = DFA47_accept;
            this.special = DFA47_special;
            this.transition = DFA47_transition;
        }
        public String getDescription() {
            return "760:1: postfixExpression : ( leftHandSideExpression '++' | leftHandSideExpression '--' | leftHandSideExpression );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA47_1 = input.LA(1);

                         
                        int index47_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA47_2 = input.LA(1);

                         
                        int index47_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA47_3 = input.LA(1);

                         
                        int index47_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA47_4 = input.LA(1);

                         
                        int index47_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA47_5 = input.LA(1);

                         
                        int index47_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA47_6 = input.LA(1);

                         
                        int index47_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA47_7 = input.LA(1);

                         
                        int index47_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA47_8 = input.LA(1);

                         
                        int index47_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA47_9 = input.LA(1);

                         
                        int index47_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred61_AS3()) ) {s = 10;}

                        else if ( (synpred62_AS3()) ) {s = 11;}

                        else if ( (true) ) {s = 12;}

                         
                        input.seek(index47_9);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 47, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA51_eotS =
        "\4\uffff";
    static final String DFA51_eofS =
        "\2\2\2\uffff";
    static final String DFA51_minS =
        "\2\4\2\uffff";
    static final String DFA51_maxS =
        "\2\u0083\2\uffff";
    static final String DFA51_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA51_specialS =
        "\4\uffff}>";
    static final String[] DFA51_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\3\3"+
            "\24\2\14\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff\3\2\4\uffff"+
            "\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\3"+
            "\3\24\2\14\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff\3\2\4"+
            "\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA51_eot = DFA.unpackEncodedString(DFA51_eotS);
    static final short[] DFA51_eof = DFA.unpackEncodedString(DFA51_eofS);
    static final char[] DFA51_min = DFA.unpackEncodedStringToUnsignedChars(DFA51_minS);
    static final char[] DFA51_max = DFA.unpackEncodedStringToUnsignedChars(DFA51_maxS);
    static final short[] DFA51_accept = DFA.unpackEncodedString(DFA51_acceptS);
    static final short[] DFA51_special = DFA.unpackEncodedString(DFA51_specialS);
    static final short[][] DFA51_transition;

    static {
        int numStates = DFA51_transitionS.length;
        DFA51_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA51_transition[i] = DFA.unpackEncodedString(DFA51_transitionS[i]);
        }
    }

    class DFA51 extends DFA {

        public DFA51(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 51;
            this.eot = DFA51_eot;
            this.eof = DFA51_eof;
            this.min = DFA51_min;
            this.max = DFA51_max;
            this.accept = DFA51_accept;
            this.special = DFA51_special;
            this.transition = DFA51_transition;
        }
        public String getDescription() {
            return "()* loopback of 772:20: ( ( LineTerminator )* ( '*' | '/' | '%' ) ( LineTerminator )* unaryExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA54_eotS =
        "\70\uffff";
    static final String DFA54_eofS =
        "\1\2\67\uffff";
    static final String DFA54_minS =
        "\1\4\1\0\35\uffff\1\0\30\uffff";
    static final String DFA54_maxS =
        "\1\u0083\1\0\35\uffff\1\0\30\uffff";
    static final String DFA54_acceptS =
        "\2\uffff\1\2\64\uffff\1\1";
    static final String DFA54_specialS =
        "\1\uffff\1\0\35\uffff\1\1\30\uffff}>";
    static final String[] DFA54_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\6\2\2\37"+
            "\2\2\3\uffff\24\2\14\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff"+
            "\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA54_eot = DFA.unpackEncodedString(DFA54_eotS);
    static final short[] DFA54_eof = DFA.unpackEncodedString(DFA54_eofS);
    static final char[] DFA54_min = DFA.unpackEncodedStringToUnsignedChars(DFA54_minS);
    static final char[] DFA54_max = DFA.unpackEncodedStringToUnsignedChars(DFA54_maxS);
    static final short[] DFA54_accept = DFA.unpackEncodedString(DFA54_acceptS);
    static final short[] DFA54_special = DFA.unpackEncodedString(DFA54_specialS);
    static final short[][] DFA54_transition;

    static {
        int numStates = DFA54_transitionS.length;
        DFA54_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA54_transition[i] = DFA.unpackEncodedString(DFA54_transitionS[i]);
        }
    }

    class DFA54 extends DFA {

        public DFA54(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 54;
            this.eot = DFA54_eot;
            this.eof = DFA54_eof;
            this.min = DFA54_min;
            this.max = DFA54_max;
            this.accept = DFA54_accept;
            this.special = DFA54_special;
            this.transition = DFA54_transition;
        }
        public String getDescription() {
            return "()* loopback of 776:29: ( ( LineTerminator )* ( '+' | '-' ) ( LineTerminator )* multiplicativeExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA54_1 = input.LA(1);

                         
                        int index54_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred81_AS3()) ) {s = 55;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index54_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA54_31 = input.LA(1);

                         
                        int index54_31 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred81_AS3()) ) {s = 55;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index54_31);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 54, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA57_eotS =
        "\4\uffff";
    static final String DFA57_eofS =
        "\2\2\2\uffff";
    static final String DFA57_minS =
        "\2\4\2\uffff";
    static final String DFA57_maxS =
        "\2\u0083\2\uffff";
    static final String DFA57_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA57_specialS =
        "\4\uffff}>";
    static final String[] DFA57_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\3\uffff"+
            "\3\3\21\2\14\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff\3\2"+
            "\4\uffff\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\3"+
            "\uffff\3\3\21\2\14\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff"+
            "\3\2\4\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA57_eot = DFA.unpackEncodedString(DFA57_eotS);
    static final short[] DFA57_eof = DFA.unpackEncodedString(DFA57_eofS);
    static final char[] DFA57_min = DFA.unpackEncodedStringToUnsignedChars(DFA57_minS);
    static final char[] DFA57_max = DFA.unpackEncodedStringToUnsignedChars(DFA57_maxS);
    static final short[] DFA57_accept = DFA.unpackEncodedString(DFA57_acceptS);
    static final short[] DFA57_special = DFA.unpackEncodedString(DFA57_specialS);
    static final short[][] DFA57_transition;

    static {
        int numStates = DFA57_transitionS.length;
        DFA57_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA57_transition[i] = DFA.unpackEncodedString(DFA57_transitionS[i]);
        }
    }

    class DFA57 extends DFA {

        public DFA57(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 57;
            this.eot = DFA57_eot;
            this.eof = DFA57_eof;
            this.min = DFA57_min;
            this.max = DFA57_max;
            this.accept = DFA57_accept;
            this.special = DFA57_special;
            this.transition = DFA57_transition;
        }
        public String getDescription() {
            return "()* loopback of 780:23: ( ( LineTerminator )* ( '<<' | '>>' | '>>>' ) ( LineTerminator )* additiveExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA60_eotS =
        "\65\uffff";
    static final String DFA60_eofS =
        "\1\2\64\uffff";
    static final String DFA60_minS =
        "\1\4\1\0\16\uffff\1\0\44\uffff";
    static final String DFA60_maxS =
        "\1\u0083\1\0\16\uffff\1\0\44\uffff";
    static final String DFA60_acceptS =
        "\2\uffff\1\2\61\uffff\1\1";
    static final String DFA60_specialS =
        "\1\uffff\1\0\16\uffff\1\1\44\uffff}>";
    static final String[] DFA60_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\6\uffff"+
            "\6\64\1\20\12\2\14\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff"+
            "\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA60_eot = DFA.unpackEncodedString(DFA60_eotS);
    static final short[] DFA60_eof = DFA.unpackEncodedString(DFA60_eofS);
    static final char[] DFA60_min = DFA.unpackEncodedStringToUnsignedChars(DFA60_minS);
    static final char[] DFA60_max = DFA.unpackEncodedStringToUnsignedChars(DFA60_maxS);
    static final short[] DFA60_accept = DFA.unpackEncodedString(DFA60_acceptS);
    static final short[] DFA60_special = DFA.unpackEncodedString(DFA60_specialS);
    static final short[][] DFA60_transition;

    static {
        int numStates = DFA60_transitionS.length;
        DFA60_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA60_transition[i] = DFA.unpackEncodedString(DFA60_transitionS[i]);
        }
    }

    class DFA60 extends DFA {

        public DFA60(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 60;
            this.eot = DFA60_eot;
            this.eof = DFA60_eof;
            this.min = DFA60_min;
            this.max = DFA60_max;
            this.accept = DFA60_accept;
            this.special = DFA60_special;
            this.transition = DFA60_transition;
        }
        public String getDescription() {
            return "()* loopback of 784:20: ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' | 'in' ) ( LineTerminator )* shiftExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA60_1 = input.LA(1);

                         
                        int index60_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred95_AS3()) ) {s = 52;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index60_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA60_16 = input.LA(1);

                         
                        int index60_16 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred95_AS3()) ) {s = 52;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index60_16);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 60, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA63_eotS =
        "\4\uffff";
    static final String DFA63_eofS =
        "\1\2\3\uffff";
    static final String DFA63_minS =
        "\2\4\2\uffff";
    static final String DFA63_maxS =
        "\2\136\2\uffff";
    static final String DFA63_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA63_specialS =
        "\4\uffff}>";
    static final String[] DFA63_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\2\27\uffff\6\3\13\2\16\uffff\1"+
            "\2",
            "\1\1\40\uffff\1\2\1\uffff\1\2\27\uffff\6\3\13\2\16\uffff\1"+
            "\2",
            "",
            ""
    };

    static final short[] DFA63_eot = DFA.unpackEncodedString(DFA63_eotS);
    static final short[] DFA63_eof = DFA.unpackEncodedString(DFA63_eofS);
    static final char[] DFA63_min = DFA.unpackEncodedStringToUnsignedChars(DFA63_minS);
    static final char[] DFA63_max = DFA.unpackEncodedStringToUnsignedChars(DFA63_maxS);
    static final short[] DFA63_accept = DFA.unpackEncodedString(DFA63_acceptS);
    static final short[] DFA63_special = DFA.unpackEncodedString(DFA63_specialS);
    static final short[][] DFA63_transition;

    static {
        int numStates = DFA63_transitionS.length;
        DFA63_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA63_transition[i] = DFA.unpackEncodedString(DFA63_transitionS[i]);
        }
    }

    class DFA63 extends DFA {

        public DFA63(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 63;
            this.eot = DFA63_eot;
            this.eof = DFA63_eof;
            this.min = DFA63_min;
            this.max = DFA63_max;
            this.accept = DFA63_accept;
            this.special = DFA63_special;
            this.transition = DFA63_transition;
        }
        public String getDescription() {
            return "()* loopback of 788:20: ( ( LineTerminator )* ( '<' | '>' | '<=' | '>=' | 'instanceof' | 'is' ) ( LineTerminator )* shiftExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA66_eotS =
        "\4\uffff";
    static final String DFA66_eofS =
        "\2\2\2\uffff";
    static final String DFA66_minS =
        "\2\4\2\uffff";
    static final String DFA66_maxS =
        "\2\u0083\2\uffff";
    static final String DFA66_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA66_specialS =
        "\4\uffff}>";
    static final String[] DFA66_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\4\3\6\2\14\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff"+
            "\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\4\3\6\2\14\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff"+
            "\3\2\4\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA66_eot = DFA.unpackEncodedString(DFA66_eotS);
    static final short[] DFA66_eof = DFA.unpackEncodedString(DFA66_eofS);
    static final char[] DFA66_min = DFA.unpackEncodedStringToUnsignedChars(DFA66_minS);
    static final char[] DFA66_max = DFA.unpackEncodedStringToUnsignedChars(DFA66_maxS);
    static final short[] DFA66_accept = DFA.unpackEncodedString(DFA66_acceptS);
    static final short[] DFA66_special = DFA.unpackEncodedString(DFA66_specialS);
    static final short[][] DFA66_transition;

    static {
        int numStates = DFA66_transitionS.length;
        DFA66_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA66_transition[i] = DFA.unpackEncodedString(DFA66_transitionS[i]);
        }
    }

    class DFA66 extends DFA {

        public DFA66(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 66;
            this.eot = DFA66_eot;
            this.eof = DFA66_eof;
            this.min = DFA66_min;
            this.max = DFA66_max;
            this.accept = DFA66_accept;
            this.special = DFA66_special;
            this.transition = DFA66_transition;
        }
        public String getDescription() {
            return "()* loopback of 792:25: ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA69_eotS =
        "\4\uffff";
    static final String DFA69_eofS =
        "\1\2\3\uffff";
    static final String DFA69_minS =
        "\2\4\2\uffff";
    static final String DFA69_maxS =
        "\2\136\2\uffff";
    static final String DFA69_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA69_specialS =
        "\4\uffff}>";
    static final String[] DFA69_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\4\3\6\2\16\uffff"+
            "\1\2",
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\4\3\6\2\16\uffff"+
            "\1\2",
            "",
            ""
    };

    static final short[] DFA69_eot = DFA.unpackEncodedString(DFA69_eotS);
    static final short[] DFA69_eof = DFA.unpackEncodedString(DFA69_eofS);
    static final char[] DFA69_min = DFA.unpackEncodedStringToUnsignedChars(DFA69_minS);
    static final char[] DFA69_max = DFA.unpackEncodedStringToUnsignedChars(DFA69_maxS);
    static final short[] DFA69_accept = DFA.unpackEncodedString(DFA69_acceptS);
    static final short[] DFA69_special = DFA.unpackEncodedString(DFA69_specialS);
    static final short[][] DFA69_transition;

    static {
        int numStates = DFA69_transitionS.length;
        DFA69_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA69_transition[i] = DFA.unpackEncodedString(DFA69_transitionS[i]);
        }
    }

    class DFA69 extends DFA {

        public DFA69(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 69;
            this.eot = DFA69_eot;
            this.eof = DFA69_eof;
            this.min = DFA69_min;
            this.max = DFA69_max;
            this.accept = DFA69_accept;
            this.special = DFA69_special;
            this.transition = DFA69_transition;
        }
        public String getDescription() {
            return "()* loopback of 796:29: ( ( LineTerminator )* ( '==' | '!=' | '===' | '!==' ) ( LineTerminator )* relationalExpressionNoIn )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA72_eotS =
        "\4\uffff";
    static final String DFA72_eofS =
        "\2\2\2\uffff";
    static final String DFA72_minS =
        "\2\4\2\uffff";
    static final String DFA72_maxS =
        "\2\u0083\2\uffff";
    static final String DFA72_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA72_specialS =
        "\4\uffff}>";
    static final String[] DFA72_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\4\uffff\1\3\5\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\4\uffff\1\3\5\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA72_eot = DFA.unpackEncodedString(DFA72_eotS);
    static final short[] DFA72_eof = DFA.unpackEncodedString(DFA72_eofS);
    static final char[] DFA72_min = DFA.unpackEncodedStringToUnsignedChars(DFA72_minS);
    static final char[] DFA72_max = DFA.unpackEncodedStringToUnsignedChars(DFA72_maxS);
    static final short[] DFA72_accept = DFA.unpackEncodedString(DFA72_acceptS);
    static final short[] DFA72_special = DFA.unpackEncodedString(DFA72_specialS);
    static final short[][] DFA72_transition;

    static {
        int numStates = DFA72_transitionS.length;
        DFA72_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA72_transition[i] = DFA.unpackEncodedString(DFA72_transitionS[i]);
        }
    }

    class DFA72 extends DFA {

        public DFA72(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 72;
            this.eot = DFA72_eot;
            this.eof = DFA72_eof;
            this.min = DFA72_min;
            this.max = DFA72_max;
            this.accept = DFA72_accept;
            this.special = DFA72_special;
            this.transition = DFA72_transition;
        }
        public String getDescription() {
            return "()* loopback of 800:23: ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA75_eotS =
        "\4\uffff";
    static final String DFA75_eofS =
        "\1\2\3\uffff";
    static final String DFA75_minS =
        "\2\4\2\uffff";
    static final String DFA75_maxS =
        "\2\136\2\uffff";
    static final String DFA75_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA75_specialS =
        "\4\uffff}>";
    static final String[] DFA75_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\4\uffff\1\3\5\2"+
            "\16\uffff\1\2",
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\4\uffff\1\3\5\2"+
            "\16\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA75_eot = DFA.unpackEncodedString(DFA75_eotS);
    static final short[] DFA75_eof = DFA.unpackEncodedString(DFA75_eofS);
    static final char[] DFA75_min = DFA.unpackEncodedStringToUnsignedChars(DFA75_minS);
    static final char[] DFA75_max = DFA.unpackEncodedStringToUnsignedChars(DFA75_maxS);
    static final short[] DFA75_accept = DFA.unpackEncodedString(DFA75_acceptS);
    static final short[] DFA75_special = DFA.unpackEncodedString(DFA75_specialS);
    static final short[][] DFA75_transition;

    static {
        int numStates = DFA75_transitionS.length;
        DFA75_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA75_transition[i] = DFA.unpackEncodedString(DFA75_transitionS[i]);
        }
    }

    class DFA75 extends DFA {

        public DFA75(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 75;
            this.eot = DFA75_eot;
            this.eof = DFA75_eof;
            this.min = DFA75_min;
            this.max = DFA75_max;
            this.accept = DFA75_accept;
            this.special = DFA75_special;
            this.transition = DFA75_transition;
        }
        public String getDescription() {
            return "()* loopback of 804:27: ( ( LineTerminator )* '&' ( LineTerminator )* equalityExpressionNoIn )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA78_eotS =
        "\4\uffff";
    static final String DFA78_eofS =
        "\2\2\2\uffff";
    static final String DFA78_minS =
        "\2\4\2\uffff";
    static final String DFA78_maxS =
        "\2\u0083\2\uffff";
    static final String DFA78_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA78_specialS =
        "\4\uffff}>";
    static final String[] DFA78_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\5\uffff\1\3\4\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\5\uffff\1\3\4\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA78_eot = DFA.unpackEncodedString(DFA78_eotS);
    static final short[] DFA78_eof = DFA.unpackEncodedString(DFA78_eofS);
    static final char[] DFA78_min = DFA.unpackEncodedStringToUnsignedChars(DFA78_minS);
    static final char[] DFA78_max = DFA.unpackEncodedStringToUnsignedChars(DFA78_maxS);
    static final short[] DFA78_accept = DFA.unpackEncodedString(DFA78_acceptS);
    static final short[] DFA78_special = DFA.unpackEncodedString(DFA78_specialS);
    static final short[][] DFA78_transition;

    static {
        int numStates = DFA78_transitionS.length;
        DFA78_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA78_transition[i] = DFA.unpackEncodedString(DFA78_transitionS[i]);
        }
    }

    class DFA78 extends DFA {

        public DFA78(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 78;
            this.eot = DFA78_eot;
            this.eof = DFA78_eof;
            this.min = DFA78_min;
            this.max = DFA78_max;
            this.accept = DFA78_accept;
            this.special = DFA78_special;
            this.transition = DFA78_transition;
        }
        public String getDescription() {
            return "()* loopback of 808:25: ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA81_eotS =
        "\4\uffff";
    static final String DFA81_eofS =
        "\1\2\3\uffff";
    static final String DFA81_minS =
        "\2\4\2\uffff";
    static final String DFA81_maxS =
        "\2\136\2\uffff";
    static final String DFA81_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA81_specialS =
        "\4\uffff}>";
    static final String[] DFA81_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\5\uffff\1\3\4\2"+
            "\16\uffff\1\2",
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\5\uffff\1\3\4\2"+
            "\16\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA81_eot = DFA.unpackEncodedString(DFA81_eotS);
    static final short[] DFA81_eof = DFA.unpackEncodedString(DFA81_eofS);
    static final char[] DFA81_min = DFA.unpackEncodedStringToUnsignedChars(DFA81_minS);
    static final char[] DFA81_max = DFA.unpackEncodedStringToUnsignedChars(DFA81_maxS);
    static final short[] DFA81_accept = DFA.unpackEncodedString(DFA81_acceptS);
    static final short[] DFA81_special = DFA.unpackEncodedString(DFA81_specialS);
    static final short[][] DFA81_transition;

    static {
        int numStates = DFA81_transitionS.length;
        DFA81_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA81_transition[i] = DFA.unpackEncodedString(DFA81_transitionS[i]);
        }
    }

    class DFA81 extends DFA {

        public DFA81(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 81;
            this.eot = DFA81_eot;
            this.eof = DFA81_eof;
            this.min = DFA81_min;
            this.max = DFA81_max;
            this.accept = DFA81_accept;
            this.special = DFA81_special;
            this.transition = DFA81_transition;
        }
        public String getDescription() {
            return "()* loopback of 812:29: ( ( LineTerminator )* '^' ( LineTerminator )* bitwiseANDExpressionNoIn )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA84_eotS =
        "\4\uffff";
    static final String DFA84_eofS =
        "\2\2\2\uffff";
    static final String DFA84_minS =
        "\2\4\2\uffff";
    static final String DFA84_maxS =
        "\2\u0083\2\uffff";
    static final String DFA84_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA84_specialS =
        "\4\uffff}>";
    static final String[] DFA84_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\6\uffff\1\3\3\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\6\uffff\1\3\3\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA84_eot = DFA.unpackEncodedString(DFA84_eotS);
    static final short[] DFA84_eof = DFA.unpackEncodedString(DFA84_eofS);
    static final char[] DFA84_min = DFA.unpackEncodedStringToUnsignedChars(DFA84_minS);
    static final char[] DFA84_max = DFA.unpackEncodedStringToUnsignedChars(DFA84_maxS);
    static final short[] DFA84_accept = DFA.unpackEncodedString(DFA84_acceptS);
    static final short[] DFA84_special = DFA.unpackEncodedString(DFA84_specialS);
    static final short[][] DFA84_transition;

    static {
        int numStates = DFA84_transitionS.length;
        DFA84_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA84_transition[i] = DFA.unpackEncodedString(DFA84_transitionS[i]);
        }
    }

    class DFA84 extends DFA {

        public DFA84(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 84;
            this.eot = DFA84_eot;
            this.eof = DFA84_eof;
            this.min = DFA84_min;
            this.max = DFA84_max;
            this.accept = DFA84_accept;
            this.special = DFA84_special;
            this.transition = DFA84_transition;
        }
        public String getDescription() {
            return "()* loopback of 816:25: ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA87_eotS =
        "\4\uffff";
    static final String DFA87_eofS =
        "\1\2\3\uffff";
    static final String DFA87_minS =
        "\2\4\2\uffff";
    static final String DFA87_maxS =
        "\2\136\2\uffff";
    static final String DFA87_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA87_specialS =
        "\4\uffff}>";
    static final String[] DFA87_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\6\uffff\1\3\3\2"+
            "\16\uffff\1\2",
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\6\uffff\1\3\3\2"+
            "\16\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA87_eot = DFA.unpackEncodedString(DFA87_eotS);
    static final short[] DFA87_eof = DFA.unpackEncodedString(DFA87_eofS);
    static final char[] DFA87_min = DFA.unpackEncodedStringToUnsignedChars(DFA87_minS);
    static final char[] DFA87_max = DFA.unpackEncodedStringToUnsignedChars(DFA87_maxS);
    static final short[] DFA87_accept = DFA.unpackEncodedString(DFA87_acceptS);
    static final short[] DFA87_special = DFA.unpackEncodedString(DFA87_specialS);
    static final short[][] DFA87_transition;

    static {
        int numStates = DFA87_transitionS.length;
        DFA87_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA87_transition[i] = DFA.unpackEncodedString(DFA87_transitionS[i]);
        }
    }

    class DFA87 extends DFA {

        public DFA87(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 87;
            this.eot = DFA87_eot;
            this.eof = DFA87_eof;
            this.min = DFA87_min;
            this.max = DFA87_max;
            this.accept = DFA87_accept;
            this.special = DFA87_special;
            this.transition = DFA87_transition;
        }
        public String getDescription() {
            return "()* loopback of 820:29: ( ( LineTerminator )* '|' ( LineTerminator )* bitwiseXORExpressionNoIn )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA90_eotS =
        "\4\uffff";
    static final String DFA90_eofS =
        "\2\2\2\uffff";
    static final String DFA90_minS =
        "\2\4\2\uffff";
    static final String DFA90_maxS =
        "\2\u0083\2\uffff";
    static final String DFA90_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA90_specialS =
        "\4\uffff}>";
    static final String[] DFA90_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\7\uffff\1\3\2\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\7\uffff\1\3\2\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA90_eot = DFA.unpackEncodedString(DFA90_eotS);
    static final short[] DFA90_eof = DFA.unpackEncodedString(DFA90_eofS);
    static final char[] DFA90_min = DFA.unpackEncodedStringToUnsignedChars(DFA90_minS);
    static final char[] DFA90_max = DFA.unpackEncodedStringToUnsignedChars(DFA90_maxS);
    static final short[] DFA90_accept = DFA.unpackEncodedString(DFA90_acceptS);
    static final short[] DFA90_special = DFA.unpackEncodedString(DFA90_specialS);
    static final short[][] DFA90_transition;

    static {
        int numStates = DFA90_transitionS.length;
        DFA90_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA90_transition[i] = DFA.unpackEncodedString(DFA90_transitionS[i]);
        }
    }

    class DFA90 extends DFA {

        public DFA90(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 90;
            this.eot = DFA90_eot;
            this.eof = DFA90_eof;
            this.min = DFA90_min;
            this.max = DFA90_max;
            this.accept = DFA90_accept;
            this.special = DFA90_special;
            this.transition = DFA90_transition;
        }
        public String getDescription() {
            return "()* loopback of 824:24: ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA93_eotS =
        "\4\uffff";
    static final String DFA93_eofS =
        "\1\2\3\uffff";
    static final String DFA93_minS =
        "\2\4\2\uffff";
    static final String DFA93_maxS =
        "\2\136\2\uffff";
    static final String DFA93_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA93_specialS =
        "\4\uffff}>";
    static final String[] DFA93_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\7\uffff\1\3\2\2"+
            "\16\uffff\1\2",
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\7\uffff\1\3\2\2"+
            "\16\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA93_eot = DFA.unpackEncodedString(DFA93_eotS);
    static final short[] DFA93_eof = DFA.unpackEncodedString(DFA93_eofS);
    static final char[] DFA93_min = DFA.unpackEncodedStringToUnsignedChars(DFA93_minS);
    static final char[] DFA93_max = DFA.unpackEncodedStringToUnsignedChars(DFA93_maxS);
    static final short[] DFA93_accept = DFA.unpackEncodedString(DFA93_acceptS);
    static final short[] DFA93_special = DFA.unpackEncodedString(DFA93_specialS);
    static final short[][] DFA93_transition;

    static {
        int numStates = DFA93_transitionS.length;
        DFA93_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA93_transition[i] = DFA.unpackEncodedString(DFA93_transitionS[i]);
        }
    }

    class DFA93 extends DFA {

        public DFA93(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 93;
            this.eot = DFA93_eot;
            this.eof = DFA93_eof;
            this.min = DFA93_min;
            this.max = DFA93_max;
            this.accept = DFA93_accept;
            this.special = DFA93_special;
            this.transition = DFA93_transition;
        }
        public String getDescription() {
            return "()* loopback of 828:28: ( ( LineTerminator )* '&&' ( LineTerminator )* bitwiseORExpressionNoIn )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA96_eotS =
        "\4\uffff";
    static final String DFA96_eofS =
        "\2\2\2\uffff";
    static final String DFA96_minS =
        "\2\4\2\uffff";
    static final String DFA96_maxS =
        "\2\u0083\2\uffff";
    static final String DFA96_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA96_specialS =
        "\4\uffff}>";
    static final String[] DFA96_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\10\uffff\1\3\1\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\13\2\2\uffff\12\2\14"+
            "\uffff\1\2\10\uffff\1\3\1\2\14\uffff\21\2\2\uffff\1\2\4\uffff"+
            "\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA96_eot = DFA.unpackEncodedString(DFA96_eotS);
    static final short[] DFA96_eof = DFA.unpackEncodedString(DFA96_eofS);
    static final char[] DFA96_min = DFA.unpackEncodedStringToUnsignedChars(DFA96_minS);
    static final char[] DFA96_max = DFA.unpackEncodedStringToUnsignedChars(DFA96_maxS);
    static final short[] DFA96_accept = DFA.unpackEncodedString(DFA96_acceptS);
    static final short[] DFA96_special = DFA.unpackEncodedString(DFA96_specialS);
    static final short[][] DFA96_transition;

    static {
        int numStates = DFA96_transitionS.length;
        DFA96_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA96_transition[i] = DFA.unpackEncodedString(DFA96_transitionS[i]);
        }
    }

    class DFA96 extends DFA {

        public DFA96(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 96;
            this.eot = DFA96_eot;
            this.eof = DFA96_eof;
            this.min = DFA96_min;
            this.max = DFA96_max;
            this.accept = DFA96_accept;
            this.special = DFA96_special;
            this.transition = DFA96_transition;
        }
        public String getDescription() {
            return "()* loopback of 832:25: ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA99_eotS =
        "\4\uffff";
    static final String DFA99_eofS =
        "\1\2\3\uffff";
    static final String DFA99_minS =
        "\2\4\2\uffff";
    static final String DFA99_maxS =
        "\2\136\2\uffff";
    static final String DFA99_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA99_specialS =
        "\4\uffff}>";
    static final String[] DFA99_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\10\uffff\1\3\1\2"+
            "\16\uffff\1\2",
            "\1\1\40\uffff\1\2\1\uffff\1\2\35\uffff\1\2\10\uffff\1\3\1"+
            "\2\16\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA99_eot = DFA.unpackEncodedString(DFA99_eotS);
    static final short[] DFA99_eof = DFA.unpackEncodedString(DFA99_eofS);
    static final char[] DFA99_min = DFA.unpackEncodedStringToUnsignedChars(DFA99_minS);
    static final char[] DFA99_max = DFA.unpackEncodedStringToUnsignedChars(DFA99_maxS);
    static final short[] DFA99_accept = DFA.unpackEncodedString(DFA99_acceptS);
    static final short[] DFA99_special = DFA.unpackEncodedString(DFA99_specialS);
    static final short[][] DFA99_transition;

    static {
        int numStates = DFA99_transitionS.length;
        DFA99_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA99_transition[i] = DFA.unpackEncodedString(DFA99_transitionS[i]);
        }
    }

    class DFA99 extends DFA {

        public DFA99(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 99;
            this.eot = DFA99_eot;
            this.eof = DFA99_eof;
            this.min = DFA99_min;
            this.max = DFA99_max;
            this.accept = DFA99_accept;
            this.special = DFA99_special;
            this.transition = DFA99_transition;
        }
        public String getDescription() {
            return "()* loopback of 836:29: ( ( LineTerminator )* '||' ( LineTerminator )* logicalANDExpressionNoIn )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA104_eotS =
        "\4\uffff";
    static final String DFA104_eofS =
        "\2\3\2\uffff";
    static final String DFA104_minS =
        "\2\4\2\uffff";
    static final String DFA104_maxS =
        "\2\u0083\2\uffff";
    static final String DFA104_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA104_specialS =
        "\4\uffff}>";
    static final String[] DFA104_transitionS = {
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\13\3\2\uffff\12\3\14"+
            "\uffff\1\3\11\uffff\1\2\14\uffff\21\3\2\uffff\1\3\4\uffff\1"+
            "\3\1\uffff\3\3\4\uffff\3\3\1\uffff\3\3",
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\13\3\2\uffff\12\3\14"+
            "\uffff\1\3\11\uffff\1\2\14\uffff\21\3\2\uffff\1\3\4\uffff\1"+
            "\3\1\uffff\3\3\4\uffff\3\3\1\uffff\3\3",
            "",
            ""
    };

    static final short[] DFA104_eot = DFA.unpackEncodedString(DFA104_eotS);
    static final short[] DFA104_eof = DFA.unpackEncodedString(DFA104_eofS);
    static final char[] DFA104_min = DFA.unpackEncodedStringToUnsignedChars(DFA104_minS);
    static final char[] DFA104_max = DFA.unpackEncodedStringToUnsignedChars(DFA104_maxS);
    static final short[] DFA104_accept = DFA.unpackEncodedString(DFA104_acceptS);
    static final short[] DFA104_special = DFA.unpackEncodedString(DFA104_specialS);
    static final short[][] DFA104_transition;

    static {
        int numStates = DFA104_transitionS.length;
        DFA104_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA104_transition[i] = DFA.unpackEncodedString(DFA104_transitionS[i]);
        }
    }

    class DFA104 extends DFA {

        public DFA104(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 104;
            this.eot = DFA104_eot;
            this.eof = DFA104_eof;
            this.min = DFA104_min;
            this.max = DFA104_max;
            this.accept = DFA104_accept;
            this.special = DFA104_special;
            this.transition = DFA104_transition;
        }
        public String getDescription() {
            return "840:24: ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA109_eotS =
        "\4\uffff";
    static final String DFA109_eofS =
        "\1\3\3\uffff";
    static final String DFA109_minS =
        "\2\4\2\uffff";
    static final String DFA109_maxS =
        "\2\136\2\uffff";
    static final String DFA109_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA109_specialS =
        "\4\uffff}>";
    static final String[] DFA109_transitionS = {
            "\1\1\40\uffff\1\3\1\uffff\1\3\35\uffff\1\3\11\uffff\1\2\16"+
            "\uffff\1\3",
            "\1\1\40\uffff\1\3\1\uffff\1\3\35\uffff\1\3\11\uffff\1\2\16"+
            "\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA109_eot = DFA.unpackEncodedString(DFA109_eotS);
    static final short[] DFA109_eof = DFA.unpackEncodedString(DFA109_eofS);
    static final char[] DFA109_min = DFA.unpackEncodedStringToUnsignedChars(DFA109_minS);
    static final char[] DFA109_max = DFA.unpackEncodedStringToUnsignedChars(DFA109_maxS);
    static final short[] DFA109_accept = DFA.unpackEncodedString(DFA109_acceptS);
    static final short[] DFA109_special = DFA.unpackEncodedString(DFA109_specialS);
    static final short[][] DFA109_transition;

    static {
        int numStates = DFA109_transitionS.length;
        DFA109_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA109_transition[i] = DFA.unpackEncodedString(DFA109_transitionS[i]);
        }
    }

    class DFA109 extends DFA {

        public DFA109(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 109;
            this.eot = DFA109_eot;
            this.eof = DFA109_eof;
            this.min = DFA109_min;
            this.max = DFA109_max;
            this.accept = DFA109_accept;
            this.special = DFA109_special;
            this.transition = DFA109_transition;
        }
        public String getDescription() {
            return "844:28: ( ( LineTerminator )* '?' ( LineTerminator )* assignmentExpression ( LineTerminator )* ':' ( LineTerminator )* assignmentExpression )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA112_eotS =
        "\14\uffff";
    static final String DFA112_eofS =
        "\14\uffff";
    static final String DFA112_minS =
        "\1\13\11\0\2\uffff";
    static final String DFA112_maxS =
        "\1\157\11\0\2\uffff";
    static final String DFA112_acceptS =
        "\12\uffff\1\1\1\2";
    static final String DFA112_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff}>";
    static final String[] DFA112_transitionS = {
            "\1\3\5\uffff\4\4\15\uffff\1\1\1\2\1\7\1\uffff\1\5\2\uffff\1"+
            "\6\2\uffff\1\11\2\uffff\12\12\66\uffff\1\10",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA112_eot = DFA.unpackEncodedString(DFA112_eotS);
    static final short[] DFA112_eof = DFA.unpackEncodedString(DFA112_eofS);
    static final char[] DFA112_min = DFA.unpackEncodedStringToUnsignedChars(DFA112_minS);
    static final char[] DFA112_max = DFA.unpackEncodedStringToUnsignedChars(DFA112_maxS);
    static final short[] DFA112_accept = DFA.unpackEncodedString(DFA112_acceptS);
    static final short[] DFA112_special = DFA.unpackEncodedString(DFA112_specialS);
    static final short[][] DFA112_transition;

    static {
        int numStates = DFA112_transitionS.length;
        DFA112_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA112_transition[i] = DFA.unpackEncodedString(DFA112_transitionS[i]);
        }
    }

    class DFA112 extends DFA {

        public DFA112(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 112;
            this.eot = DFA112_eot;
            this.eof = DFA112_eof;
            this.min = DFA112_min;
            this.max = DFA112_max;
            this.accept = DFA112_accept;
            this.special = DFA112_special;
            this.transition = DFA112_transition;
        }
        public String getDescription() {
            return "847:1: assignmentExpression : ( conditionalExpression | leftHandSideExpression ( LineTerminator )* assignmentOperator ( LineTerminator )* assignmentExpression );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA112_1 = input.LA(1);

                         
                        int index112_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA112_2 = input.LA(1);

                         
                        int index112_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA112_3 = input.LA(1);

                         
                        int index112_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA112_4 = input.LA(1);

                         
                        int index112_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA112_5 = input.LA(1);

                         
                        int index112_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA112_6 = input.LA(1);

                         
                        int index112_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA112_7 = input.LA(1);

                         
                        int index112_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA112_8 = input.LA(1);

                         
                        int index112_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA112_9 = input.LA(1);

                         
                        int index112_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred156_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index112_9);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 112, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA115_eotS =
        "\14\uffff";
    static final String DFA115_eofS =
        "\14\uffff";
    static final String DFA115_minS =
        "\1\13\11\0\2\uffff";
    static final String DFA115_maxS =
        "\1\157\11\0\2\uffff";
    static final String DFA115_acceptS =
        "\12\uffff\1\1\1\2";
    static final String DFA115_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\2\uffff}>";
    static final String[] DFA115_transitionS = {
            "\1\3\5\uffff\4\4\15\uffff\1\1\1\2\1\7\1\uffff\1\5\2\uffff\1"+
            "\6\2\uffff\1\11\2\uffff\12\12\66\uffff\1\10",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA115_eot = DFA.unpackEncodedString(DFA115_eotS);
    static final short[] DFA115_eof = DFA.unpackEncodedString(DFA115_eofS);
    static final char[] DFA115_min = DFA.unpackEncodedStringToUnsignedChars(DFA115_minS);
    static final char[] DFA115_max = DFA.unpackEncodedStringToUnsignedChars(DFA115_maxS);
    static final short[] DFA115_accept = DFA.unpackEncodedString(DFA115_acceptS);
    static final short[] DFA115_special = DFA.unpackEncodedString(DFA115_specialS);
    static final short[][] DFA115_transition;

    static {
        int numStates = DFA115_transitionS.length;
        DFA115_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA115_transition[i] = DFA.unpackEncodedString(DFA115_transitionS[i]);
        }
    }

    class DFA115 extends DFA {

        public DFA115(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 115;
            this.eot = DFA115_eot;
            this.eof = DFA115_eof;
            this.min = DFA115_min;
            this.max = DFA115_max;
            this.accept = DFA115_accept;
            this.special = DFA115_special;
            this.transition = DFA115_transition;
        }
        public String getDescription() {
            return "852:1: assignmentExpressionNoIn : ( conditionalExpressionNoIn | leftHandSideExpression ( LineTerminator )* assignmentOperator ( LineTerminator )* assignmentExpressionNoIn );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA115_1 = input.LA(1);

                         
                        int index115_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA115_2 = input.LA(1);

                         
                        int index115_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA115_3 = input.LA(1);

                         
                        int index115_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA115_4 = input.LA(1);

                         
                        int index115_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA115_5 = input.LA(1);

                         
                        int index115_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA115_6 = input.LA(1);

                         
                        int index115_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA115_7 = input.LA(1);

                         
                        int index115_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA115_8 = input.LA(1);

                         
                        int index115_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA115_9 = input.LA(1);

                         
                        int index115_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred159_AS3()) ) {s = 10;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index115_9);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 115, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA118_eotS =
        "\4\uffff";
    static final String DFA118_eofS =
        "\2\2\2\uffff";
    static final String DFA118_minS =
        "\2\4\2\uffff";
    static final String DFA118_maxS =
        "\2\u0083\2\uffff";
    static final String DFA118_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA118_specialS =
        "\4\uffff}>";
    static final String[] DFA118_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\5\2\1\3\5\2\2\uffff\12"+
            "\2\43\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff\3\2\4\uffff"+
            "\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\5\2\1\3\5\2\2\uffff"+
            "\12\2\43\uffff\21\2\2\uffff\1\2\4\uffff\1\2\1\uffff\3\2\4\uffff"+
            "\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA118_eot = DFA.unpackEncodedString(DFA118_eotS);
    static final short[] DFA118_eof = DFA.unpackEncodedString(DFA118_eofS);
    static final char[] DFA118_min = DFA.unpackEncodedStringToUnsignedChars(DFA118_minS);
    static final char[] DFA118_max = DFA.unpackEncodedStringToUnsignedChars(DFA118_maxS);
    static final short[] DFA118_accept = DFA.unpackEncodedString(DFA118_acceptS);
    static final short[] DFA118_special = DFA.unpackEncodedString(DFA118_specialS);
    static final short[][] DFA118_transition;

    static {
        int numStates = DFA118_transitionS.length;
        DFA118_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA118_transition[i] = DFA.unpackEncodedString(DFA118_transitionS[i]);
        }
    }

    class DFA118 extends DFA {

        public DFA118(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 118;
            this.eot = DFA118_eot;
            this.eof = DFA118_eof;
            this.min = DFA118_min;
            this.max = DFA118_max;
            this.accept = DFA118_accept;
            this.special = DFA118_special;
            this.transition = DFA118_transition;
        }
        public String getDescription() {
            return "()* loopback of 862:25: ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpression )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA121_eotS =
        "\4\uffff";
    static final String DFA121_eofS =
        "\1\2\3\uffff";
    static final String DFA121_minS =
        "\2\4\2\uffff";
    static final String DFA121_maxS =
        "\2\136\2\uffff";
    static final String DFA121_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA121_specialS =
        "\4\uffff}>";
    static final String[] DFA121_transitionS = {
            "\1\1\42\uffff\1\3\66\uffff\1\2",
            "\1\1\42\uffff\1\3\66\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA121_eot = DFA.unpackEncodedString(DFA121_eotS);
    static final short[] DFA121_eof = DFA.unpackEncodedString(DFA121_eofS);
    static final char[] DFA121_min = DFA.unpackEncodedStringToUnsignedChars(DFA121_minS);
    static final char[] DFA121_max = DFA.unpackEncodedStringToUnsignedChars(DFA121_maxS);
    static final short[] DFA121_accept = DFA.unpackEncodedString(DFA121_acceptS);
    static final short[] DFA121_special = DFA.unpackEncodedString(DFA121_specialS);
    static final short[][] DFA121_transition;

    static {
        int numStates = DFA121_transitionS.length;
        DFA121_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA121_transition[i] = DFA.unpackEncodedString(DFA121_transitionS[i]);
        }
    }

    class DFA121 extends DFA {

        public DFA121(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 121;
            this.eot = DFA121_eot;
            this.eof = DFA121_eof;
            this.min = DFA121_min;
            this.max = DFA121_max;
            this.accept = DFA121_accept;
            this.special = DFA121_special;
            this.transition = DFA121_transition;
        }
        public String getDescription() {
            return "()* loopback of 866:29: ( ( LineTerminator )* ',' ( LineTerminator )* assignmentExpressionNoIn )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA122_eotS =
        "\36\uffff";
    static final String DFA122_eofS =
        "\36\uffff";
    static final String DFA122_minS =
        "\1\13\1\0\4\uffff\1\0\1\uffff\1\0\25\uffff";
    static final String DFA122_maxS =
        "\1\u0081\1\0\4\uffff\1\0\1\uffff\1\0\25\uffff";
    static final String DFA122_acceptS =
        "\2\uffff\1\2\1\3\1\4\10\uffff\1\5\1\6\2\uffff\1\7\1\10\1\11\1\12"+
        "\1\14\1\15\1\16\1\17\1\20\1\21\1\1\1\13\1\22";
    static final String DFA122_specialS =
        "\1\uffff\1\0\4\uffff\1\1\1\uffff\1\2\25\uffff}>";
    static final String[] DFA122_transitionS = {
            "\1\6\5\uffff\4\4\15\uffff\3\4\1\uffff\1\10\2\uffff\1\1\2\uffff"+
            "\1\4\2\uffff\12\4\43\uffff\2\2\1\3\1\15\1\uffff\3\16\1\21\1"+
            "\22\1\23\1\24\1\25\2\uffff\1\26\1\27\2\uffff\1\4\4\uffff\1\32"+
            "\12\uffff\1\30\1\uffff\1\31",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA122_eot = DFA.unpackEncodedString(DFA122_eotS);
    static final short[] DFA122_eof = DFA.unpackEncodedString(DFA122_eofS);
    static final char[] DFA122_min = DFA.unpackEncodedStringToUnsignedChars(DFA122_minS);
    static final char[] DFA122_max = DFA.unpackEncodedStringToUnsignedChars(DFA122_maxS);
    static final short[] DFA122_accept = DFA.unpackEncodedString(DFA122_acceptS);
    static final short[] DFA122_special = DFA.unpackEncodedString(DFA122_specialS);
    static final short[][] DFA122_transition;

    static {
        int numStates = DFA122_transitionS.length;
        DFA122_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA122_transition[i] = DFA.unpackEncodedString(DFA122_transitionS[i]);
        }
    }

    class DFA122 extends DFA {

        public DFA122(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 122;
            this.eot = DFA122_eot;
            this.eof = DFA122_eof;
            this.min = DFA122_min;
            this.max = DFA122_max;
            this.accept = DFA122_accept;
            this.special = DFA122_special;
            this.transition = DFA122_transition;
        }
        public String getDescription() {
            return "873:1: statement : ( blockStatement | variableStatement | emptyStatement | expressionStatement | ifStatement | iterationStatement | continueStatement | breakStatement | returnStatement | withStatement | labelledStatement | switchStatement | throwStatement | tryStatement | useNamespaceStatement | includeStatement | importStatement | metaDataStatement );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA122_1 = input.LA(1);

                         
                        int index122_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred179_AS3()) ) {s = 27;}

                        else if ( (synpred182_AS3()) ) {s = 4;}

                         
                        input.seek(index122_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA122_6 = input.LA(1);

                         
                        int index122_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred182_AS3()) ) {s = 4;}

                        else if ( (synpred189_AS3()) ) {s = 28;}

                         
                        input.seek(index122_6);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA122_8 = input.LA(1);

                         
                        int index122_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred182_AS3()) ) {s = 4;}

                        else if ( (true) ) {s = 29;}

                         
                        input.seek(index122_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 122, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA128_eotS =
        "\4\uffff";
    static final String DFA128_eofS =
        "\1\2\3\uffff";
    static final String DFA128_minS =
        "\2\4\2\uffff";
    static final String DFA128_maxS =
        "\2\u0081\2\uffff";
    static final String DFA128_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA128_specialS =
        "\4\uffff}>";
    static final String[] DFA128_transitionS = {
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\3\3\1\uffff\1\3\2\uffff"+
            "\1\3\1\2\1\uffff\1\3\2\uffff\12\3\43\uffff\4\3\1\uffff\10\3"+
            "\2\2\2\3\2\uffff\1\3\4\uffff\1\3\12\uffff\1\3\1\uffff\1\3",
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\3\3\1\uffff\1\3\2\uffff"+
            "\1\3\1\2\1\uffff\1\3\2\uffff\12\3\43\uffff\4\3\1\uffff\10\3"+
            "\2\2\2\3\2\uffff\1\3\4\uffff\1\3\12\uffff\1\3\1\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA128_eot = DFA.unpackEncodedString(DFA128_eotS);
    static final short[] DFA128_eof = DFA.unpackEncodedString(DFA128_eofS);
    static final char[] DFA128_min = DFA.unpackEncodedStringToUnsignedChars(DFA128_minS);
    static final char[] DFA128_max = DFA.unpackEncodedStringToUnsignedChars(DFA128_maxS);
    static final short[] DFA128_accept = DFA.unpackEncodedString(DFA128_acceptS);
    static final short[] DFA128_special = DFA.unpackEncodedString(DFA128_specialS);
    static final short[][] DFA128_transition;

    static {
        int numStates = DFA128_transitionS.length;
        DFA128_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA128_transition[i] = DFA.unpackEncodedString(DFA128_transitionS[i]);
        }
    }

    class DFA128 extends DFA {

        public DFA128(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 128;
            this.eot = DFA128_eot;
            this.eof = DFA128_eof;
            this.min = DFA128_min;
            this.max = DFA128_max;
            this.accept = DFA128_accept;
            this.special = DFA128_special;
            this.transition = DFA128_transition;
        }
        public String getDescription() {
            return "()* loopback of 899:4: ( ( LineTerminator )* statement ( LineTerminator )* )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA134_eotS =
        "\4\uffff";
    static final String DFA134_eofS =
        "\2\2\2\uffff";
    static final String DFA134_minS =
        "\2\4\2\uffff";
    static final String DFA134_maxS =
        "\2\u0083\2\uffff";
    static final String DFA134_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA134_specialS =
        "\4\uffff}>";
    static final String[] DFA134_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\1\3\1"+
            "\uffff\2\2\1\uffff\1\2\2\uffff\12\2\43\uffff\21\2\2\uffff\1"+
            "\2\4\uffff\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\1\3"+
            "\1\uffff\2\2\1\uffff\1\2\2\uffff\12\2\43\uffff\21\2\2\uffff"+
            "\1\2\4\uffff\1\2\1\uffff\3\2\4\uffff\3\2\1\uffff\3\2",
            "",
            ""
    };

    static final short[] DFA134_eot = DFA.unpackEncodedString(DFA134_eotS);
    static final short[] DFA134_eof = DFA.unpackEncodedString(DFA134_eofS);
    static final char[] DFA134_min = DFA.unpackEncodedStringToUnsignedChars(DFA134_minS);
    static final char[] DFA134_max = DFA.unpackEncodedStringToUnsignedChars(DFA134_maxS);
    static final short[] DFA134_accept = DFA.unpackEncodedString(DFA134_acceptS);
    static final short[] DFA134_special = DFA.unpackEncodedString(DFA134_specialS);
    static final short[][] DFA134_transition;

    static {
        int numStates = DFA134_transitionS.length;
        DFA134_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA134_transition[i] = DFA.unpackEncodedString(DFA134_transitionS[i]);
        }
    }

    class DFA134 extends DFA {

        public DFA134(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 134;
            this.eot = DFA134_eot;
            this.eof = DFA134_eof;
            this.min = DFA134_min;
            this.max = DFA134_max;
            this.accept = DFA134_accept;
            this.special = DFA134_special;
            this.transition = DFA134_transition;
        }
        public String getDescription() {
            return "()* loopback of 907:24: ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclaration )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA137_eotS =
        "\4\uffff";
    static final String DFA137_eofS =
        "\1\2\3\uffff";
    static final String DFA137_minS =
        "\2\4\2\uffff";
    static final String DFA137_maxS =
        "\2\136\2\uffff";
    static final String DFA137_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA137_specialS =
        "\4\uffff}>";
    static final String[] DFA137_transitionS = {
            "\1\1\42\uffff\1\3\66\uffff\1\2",
            "\1\1\42\uffff\1\3\66\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA137_eot = DFA.unpackEncodedString(DFA137_eotS);
    static final short[] DFA137_eof = DFA.unpackEncodedString(DFA137_eofS);
    static final char[] DFA137_min = DFA.unpackEncodedStringToUnsignedChars(DFA137_minS);
    static final char[] DFA137_max = DFA.unpackEncodedStringToUnsignedChars(DFA137_maxS);
    static final short[] DFA137_accept = DFA.unpackEncodedString(DFA137_acceptS);
    static final short[] DFA137_special = DFA.unpackEncodedString(DFA137_specialS);
    static final short[][] DFA137_transition;

    static {
        int numStates = DFA137_transitionS.length;
        DFA137_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA137_transition[i] = DFA.unpackEncodedString(DFA137_transitionS[i]);
        }
    }

    class DFA137 extends DFA {

        public DFA137(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 137;
            this.eot = DFA137_eot;
            this.eof = DFA137_eof;
            this.min = DFA137_min;
            this.max = DFA137_max;
            this.accept = DFA137_accept;
            this.special = DFA137_special;
            this.transition = DFA137_transition;
        }
        public String getDescription() {
            return "()* loopback of 911:28: ( ( LineTerminator )* ',' ( LineTerminator )* variableDeclarationNoIn )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA169_eotS =
        "\4\uffff";
    static final String DFA169_eofS =
        "\4\uffff";
    static final String DFA169_minS =
        "\2\4\2\uffff";
    static final String DFA169_maxS =
        "\2\157\2\uffff";
    static final String DFA169_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA169_specialS =
        "\4\uffff}>";
    static final String[] DFA169_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\2\uffff"+
            "\1\2\2\uffff\1\2\2\uffff\12\2\43\uffff\1\2\1\uffff\1\3\20\uffff"+
            "\1\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\2\uffff"+
            "\1\2\2\uffff\1\2\2\uffff\12\2\43\uffff\1\2\1\uffff\1\3\20\uffff"+
            "\1\2",
            "",
            ""
    };

    static final short[] DFA169_eot = DFA.unpackEncodedString(DFA169_eotS);
    static final short[] DFA169_eof = DFA.unpackEncodedString(DFA169_eofS);
    static final char[] DFA169_min = DFA.unpackEncodedStringToUnsignedChars(DFA169_minS);
    static final char[] DFA169_max = DFA.unpackEncodedStringToUnsignedChars(DFA169_maxS);
    static final short[] DFA169_accept = DFA.unpackEncodedString(DFA169_acceptS);
    static final short[] DFA169_special = DFA.unpackEncodedString(DFA169_specialS);
    static final short[][] DFA169_transition;

    static {
        int numStates = DFA169_transitionS.length;
        DFA169_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA169_transition[i] = DFA.unpackEncodedString(DFA169_transitionS[i]);
        }
    }

    class DFA169 extends DFA {

        public DFA169(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 169;
            this.eot = DFA169_eot;
            this.eof = DFA169_eof;
            this.min = DFA169_min;
            this.max = DFA169_max;
            this.accept = DFA169_accept;
            this.special = DFA169_special;
            this.transition = DFA169_transition;
        }
        public String getDescription() {
            return "958:30: ( ( LineTerminator )* forStatementInitialiserPart )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA172_eotS =
        "\4\uffff";
    static final String DFA172_eofS =
        "\4\uffff";
    static final String DFA172_minS =
        "\2\4\2\uffff";
    static final String DFA172_maxS =
        "\2\157\2\uffff";
    static final String DFA172_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA172_specialS =
        "\4\uffff}>";
    static final String[] DFA172_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\2\uffff"+
            "\1\2\2\uffff\1\2\2\uffff\12\2\45\uffff\1\3\20\uffff\1\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\2\uffff"+
            "\1\2\2\uffff\1\2\2\uffff\12\2\45\uffff\1\3\20\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA172_eot = DFA.unpackEncodedString(DFA172_eotS);
    static final short[] DFA172_eof = DFA.unpackEncodedString(DFA172_eofS);
    static final char[] DFA172_min = DFA.unpackEncodedStringToUnsignedChars(DFA172_minS);
    static final char[] DFA172_max = DFA.unpackEncodedStringToUnsignedChars(DFA172_maxS);
    static final short[] DFA172_accept = DFA.unpackEncodedString(DFA172_acceptS);
    static final short[] DFA172_special = DFA.unpackEncodedString(DFA172_specialS);
    static final short[][] DFA172_transition;

    static {
        int numStates = DFA172_transitionS.length;
        DFA172_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA172_transition[i] = DFA.unpackEncodedString(DFA172_transitionS[i]);
        }
    }

    class DFA172 extends DFA {

        public DFA172(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 172;
            this.eot = DFA172_eot;
            this.eof = DFA172_eof;
            this.min = DFA172_min;
            this.max = DFA172_max;
            this.accept = DFA172_accept;
            this.special = DFA172_special;
            this.transition = DFA172_transition;
        }
        public String getDescription() {
            return "958:97: ( ( LineTerminator )* expression )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA175_eotS =
        "\4\uffff";
    static final String DFA175_eofS =
        "\4\uffff";
    static final String DFA175_minS =
        "\2\4\2\uffff";
    static final String DFA175_maxS =
        "\2\157\2\uffff";
    static final String DFA175_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA175_specialS =
        "\4\uffff}>";
    static final String[] DFA175_transitionS = {
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\3\1\2\2\uffff\1"+
            "\2\2\uffff\1\2\2\uffff\12\2\66\uffff\1\2",
            "\1\1\6\uffff\1\2\5\uffff\4\2\15\uffff\3\2\1\3\1\2\2\uffff"+
            "\1\2\2\uffff\1\2\2\uffff\12\2\66\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA175_eot = DFA.unpackEncodedString(DFA175_eotS);
    static final short[] DFA175_eof = DFA.unpackEncodedString(DFA175_eofS);
    static final char[] DFA175_min = DFA.unpackEncodedStringToUnsignedChars(DFA175_minS);
    static final char[] DFA175_max = DFA.unpackEncodedStringToUnsignedChars(DFA175_maxS);
    static final short[] DFA175_accept = DFA.unpackEncodedString(DFA175_acceptS);
    static final short[] DFA175_special = DFA.unpackEncodedString(DFA175_specialS);
    static final short[][] DFA175_transition;

    static {
        int numStates = DFA175_transitionS.length;
        DFA175_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA175_transition[i] = DFA.unpackEncodedString(DFA175_transitionS[i]);
        }
    }

    class DFA175 extends DFA {

        public DFA175(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 175;
            this.eot = DFA175_eot;
            this.eof = DFA175_eof;
            this.min = DFA175_min;
            this.max = DFA175_max;
            this.accept = DFA175_accept;
            this.special = DFA175_special;
            this.transition = DFA175_transition;
        }
        public String getDescription() {
            return "958:147: ( ( LineTerminator )* expression )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA194_eotS =
        "\51\uffff";
    static final String DFA194_eofS =
        "\1\13\50\uffff";
    static final String DFA194_minS =
        "\1\4\12\0\36\uffff";
    static final String DFA194_maxS =
        "\1\u0083\12\0\36\uffff";
    static final String DFA194_acceptS =
        "\13\uffff\1\2\34\uffff\1\1";
    static final String DFA194_specialS =
        "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\36\uffff}>";
    static final String[] DFA194_transitionS = {
            "\1\13\6\uffff\1\3\5\uffff\4\4\15\uffff\1\1\1\2\1\7\1\uffff"+
            "\1\5\2\uffff\1\6\1\13\1\uffff\1\11\2\uffff\12\12\43\uffff\21"+
            "\13\2\uffff\1\10\4\uffff\1\13\1\uffff\3\13\4\uffff\3\13\1\uffff"+
            "\3\13",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA194_eot = DFA.unpackEncodedString(DFA194_eotS);
    static final short[] DFA194_eof = DFA.unpackEncodedString(DFA194_eofS);
    static final char[] DFA194_min = DFA.unpackEncodedStringToUnsignedChars(DFA194_minS);
    static final char[] DFA194_max = DFA.unpackEncodedStringToUnsignedChars(DFA194_maxS);
    static final short[] DFA194_accept = DFA.unpackEncodedString(DFA194_acceptS);
    static final short[] DFA194_special = DFA.unpackEncodedString(DFA194_specialS);
    static final short[][] DFA194_transition;

    static {
        int numStates = DFA194_transitionS.length;
        DFA194_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA194_transition[i] = DFA.unpackEncodedString(DFA194_transitionS[i]);
        }
    }

    class DFA194 extends DFA {

        public DFA194(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 194;
            this.eot = DFA194_eot;
            this.eof = DFA194_eof;
            this.min = DFA194_min;
            this.max = DFA194_max;
            this.accept = DFA194_accept;
            this.special = DFA194_special;
            this.transition = DFA194_transition;
        }
        public String getDescription() {
            return "984:13: ( expression )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA194_1 = input.LA(1);

                         
                        int index194_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA194_2 = input.LA(1);

                         
                        int index194_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA194_3 = input.LA(1);

                         
                        int index194_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_3);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA194_4 = input.LA(1);

                         
                        int index194_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_4);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA194_5 = input.LA(1);

                         
                        int index194_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_5);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA194_6 = input.LA(1);

                         
                        int index194_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_6);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA194_7 = input.LA(1);

                         
                        int index194_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_7);
                        if ( s>=0 ) return s;
                        break;
                    case 7 : 
                        int LA194_8 = input.LA(1);

                         
                        int index194_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_8);
                        if ( s>=0 ) return s;
                        break;
                    case 8 : 
                        int LA194_9 = input.LA(1);

                         
                        int index194_9 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_9);
                        if ( s>=0 ) return s;
                        break;
                    case 9 : 
                        int LA194_10 = input.LA(1);

                         
                        int index194_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred270_AS3()) ) {s = 40;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index194_10);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 194, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA206_eotS =
        "\4\uffff";
    static final String DFA206_eofS =
        "\4\uffff";
    static final String DFA206_minS =
        "\2\4\2\uffff";
    static final String DFA206_maxS =
        "\2\152\2\uffff";
    static final String DFA206_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA206_specialS =
        "\4\uffff}>";
    static final String[] DFA206_transitionS = {
            "\1\1\45\uffff\1\2\76\uffff\1\3\1\2",
            "\1\1\45\uffff\1\2\76\uffff\1\3\1\2",
            "",
            ""
    };

    static final short[] DFA206_eot = DFA.unpackEncodedString(DFA206_eotS);
    static final short[] DFA206_eof = DFA.unpackEncodedString(DFA206_eofS);
    static final char[] DFA206_min = DFA.unpackEncodedStringToUnsignedChars(DFA206_minS);
    static final char[] DFA206_max = DFA.unpackEncodedStringToUnsignedChars(DFA206_maxS);
    static final short[] DFA206_accept = DFA.unpackEncodedString(DFA206_acceptS);
    static final short[] DFA206_special = DFA.unpackEncodedString(DFA206_specialS);
    static final short[][] DFA206_transition;

    static {
        int numStates = DFA206_transitionS.length;
        DFA206_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA206_transition[i] = DFA.unpackEncodedString(DFA206_transitionS[i]);
        }
    }

    class DFA206 extends DFA {

        public DFA206(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 206;
            this.eot = DFA206_eot;
            this.eof = DFA206_eof;
            this.min = DFA206_min;
            this.max = DFA206_max;
            this.accept = DFA206_accept;
            this.special = DFA206_special;
            this.transition = DFA206_transition;
        }
        public String getDescription() {
            return "()* loopback of 996:8: ( ( LineTerminator )* caseClause )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA210_eotS =
        "\4\uffff";
    static final String DFA210_eofS =
        "\4\uffff";
    static final String DFA210_minS =
        "\2\4\2\uffff";
    static final String DFA210_maxS =
        "\2\152\2\uffff";
    static final String DFA210_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA210_specialS =
        "\4\uffff}>";
    static final String[] DFA210_transitionS = {
            "\1\1\45\uffff\1\3\77\uffff\1\2",
            "\1\1\45\uffff\1\3\77\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA210_eot = DFA.unpackEncodedString(DFA210_eotS);
    static final short[] DFA210_eof = DFA.unpackEncodedString(DFA210_eofS);
    static final char[] DFA210_min = DFA.unpackEncodedStringToUnsignedChars(DFA210_minS);
    static final char[] DFA210_max = DFA.unpackEncodedStringToUnsignedChars(DFA210_maxS);
    static final short[] DFA210_accept = DFA.unpackEncodedString(DFA210_acceptS);
    static final short[] DFA210_special = DFA.unpackEncodedString(DFA210_specialS);
    static final short[][] DFA210_transition;

    static {
        int numStates = DFA210_transitionS.length;
        DFA210_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA210_transition[i] = DFA.unpackEncodedString(DFA210_transitionS[i]);
        }
    }

    class DFA210 extends DFA {

        public DFA210(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 210;
            this.eot = DFA210_eot;
            this.eof = DFA210_eof;
            this.min = DFA210_min;
            this.max = DFA210_max;
            this.accept = DFA210_accept;
            this.special = DFA210_special;
            this.transition = DFA210_transition;
        }
        public String getDescription() {
            return "996:38: ( ( LineTerminator )* defaultClause ( ( LineTerminator )* caseClause )* )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA209_eotS =
        "\4\uffff";
    static final String DFA209_eofS =
        "\4\uffff";
    static final String DFA209_minS =
        "\2\4\2\uffff";
    static final String DFA209_maxS =
        "\2\151\2\uffff";
    static final String DFA209_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA209_specialS =
        "\4\uffff}>";
    static final String[] DFA209_transitionS = {
            "\1\1\45\uffff\1\2\76\uffff\1\3",
            "\1\1\45\uffff\1\2\76\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA209_eot = DFA.unpackEncodedString(DFA209_eotS);
    static final short[] DFA209_eof = DFA.unpackEncodedString(DFA209_eofS);
    static final char[] DFA209_min = DFA.unpackEncodedStringToUnsignedChars(DFA209_minS);
    static final char[] DFA209_max = DFA.unpackEncodedStringToUnsignedChars(DFA209_maxS);
    static final short[] DFA209_accept = DFA.unpackEncodedString(DFA209_acceptS);
    static final short[] DFA209_special = DFA.unpackEncodedString(DFA209_specialS);
    static final short[][] DFA209_transition;

    static {
        int numStates = DFA209_transitionS.length;
        DFA209_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA209_transition[i] = DFA.unpackEncodedString(DFA209_transitionS[i]);
        }
    }

    class DFA209 extends DFA {

        public DFA209(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 209;
            this.eot = DFA209_eot;
            this.eof = DFA209_eof;
            this.min = DFA209_min;
            this.max = DFA209_max;
            this.accept = DFA209_accept;
            this.special = DFA209_special;
            this.transition = DFA209_transition;
        }
        public String getDescription() {
            return "()* loopback of 996:69: ( ( LineTerminator )* caseClause )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA256_eotS =
        "\4\uffff";
    static final String DFA256_eofS =
        "\4\uffff";
    static final String DFA256_minS =
        "\2\4\2\uffff";
    static final String DFA256_maxS =
        "\2\162\2\uffff";
    static final String DFA256_acceptS =
        "\2\uffff\1\1\1\2";
    static final String DFA256_specialS =
        "\4\uffff}>";
    static final String[] DFA256_transitionS = {
            "\1\1\6\uffff\1\2\31\uffff\1\3\114\uffff\1\2",
            "\1\1\6\uffff\1\2\31\uffff\1\3\114\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA256_eot = DFA.unpackEncodedString(DFA256_eotS);
    static final short[] DFA256_eof = DFA.unpackEncodedString(DFA256_eofS);
    static final char[] DFA256_min = DFA.unpackEncodedStringToUnsignedChars(DFA256_minS);
    static final char[] DFA256_max = DFA.unpackEncodedStringToUnsignedChars(DFA256_maxS);
    static final short[] DFA256_accept = DFA.unpackEncodedString(DFA256_acceptS);
    static final short[] DFA256_special = DFA.unpackEncodedString(DFA256_specialS);
    static final short[][] DFA256_transition;

    static {
        int numStates = DFA256_transitionS.length;
        DFA256_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA256_transition[i] = DFA.unpackEncodedString(DFA256_transitionS[i]);
        }
    }

    class DFA256 extends DFA {

        public DFA256(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 256;
            this.eot = DFA256_eot;
            this.eof = DFA256_eof;
            this.min = DFA256_min;
            this.max = DFA256_max;
            this.accept = DFA256_accept;
            this.special = DFA256_special;
            this.transition = DFA256_transition;
        }
        public String getDescription() {
            return "1040:8: ( ( LineTerminator )* formalParameter ( ( LineTerminator )* ',' ( LineTerminator )* formalParameter )* )?";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA255_eotS =
        "\4\uffff";
    static final String DFA255_eofS =
        "\4\uffff";
    static final String DFA255_minS =
        "\2\4\2\uffff";
    static final String DFA255_maxS =
        "\2\47\2\uffff";
    static final String DFA255_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA255_specialS =
        "\4\uffff}>";
    static final String[] DFA255_transitionS = {
            "\1\1\40\uffff\1\2\1\uffff\1\3",
            "\1\1\40\uffff\1\2\1\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA255_eot = DFA.unpackEncodedString(DFA255_eotS);
    static final short[] DFA255_eof = DFA.unpackEncodedString(DFA255_eofS);
    static final char[] DFA255_min = DFA.unpackEncodedStringToUnsignedChars(DFA255_minS);
    static final char[] DFA255_max = DFA.unpackEncodedStringToUnsignedChars(DFA255_maxS);
    static final short[] DFA255_accept = DFA.unpackEncodedString(DFA255_acceptS);
    static final short[] DFA255_special = DFA.unpackEncodedString(DFA255_specialS);
    static final short[][] DFA255_transition;

    static {
        int numStates = DFA255_transitionS.length;
        DFA255_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA255_transition[i] = DFA.unpackEncodedString(DFA255_transitionS[i]);
        }
    }

    class DFA255 extends DFA {

        public DFA255(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 255;
            this.eot = DFA255_eot;
            this.eof = DFA255_eof;
            this.min = DFA255_min;
            this.max = DFA255_max;
            this.accept = DFA255_accept;
            this.special = DFA255_special;
            this.transition = DFA255_transition;
        }
        public String getDescription() {
            return "()* loopback of 1040:41: ( ( LineTerminator )* ',' ( LineTerminator )* formalParameter )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA264_eotS =
        "\6\uffff";
    static final String DFA264_eofS =
        "\1\uffff\1\4\1\uffff\1\4\2\uffff";
    static final String DFA264_minS =
        "\1\13\1\4\1\uffff\1\4\2\uffff";
    static final String DFA264_maxS =
        "\2\162\1\uffff\1\162\2\uffff";
    static final String DFA264_acceptS =
        "\2\uffff\1\2\1\uffff\1\1\1\3";
    static final String DFA264_specialS =
        "\6\uffff}>";
    static final String[] DFA264_transitionS = {
            "\1\1\146\uffff\1\2",
            "\1\3\40\uffff\1\4\1\uffff\1\4\3\uffff\1\4\44\uffff\1\4\41"+
            "\uffff\1\5",
            "",
            "\1\3\40\uffff\1\4\1\uffff\1\4\3\uffff\1\4\44\uffff\1\4\41"+
            "\uffff\1\5",
            "",
            ""
    };

    static final short[] DFA264_eot = DFA.unpackEncodedString(DFA264_eotS);
    static final short[] DFA264_eof = DFA.unpackEncodedString(DFA264_eofS);
    static final char[] DFA264_min = DFA.unpackEncodedStringToUnsignedChars(DFA264_minS);
    static final char[] DFA264_max = DFA.unpackEncodedStringToUnsignedChars(DFA264_maxS);
    static final short[] DFA264_accept = DFA.unpackEncodedString(DFA264_acceptS);
    static final short[] DFA264_special = DFA.unpackEncodedString(DFA264_specialS);
    static final short[][] DFA264_transition;

    static {
        int numStates = DFA264_transitionS.length;
        DFA264_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA264_transition[i] = DFA.unpackEncodedString(DFA264_transitionS[i]);
        }
    }

    class DFA264 extends DFA {

        public DFA264(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 264;
            this.eot = DFA264_eot;
            this.eof = DFA264_eof;
            this.min = DFA264_min;
            this.max = DFA264_max;
            this.accept = DFA264_accept;
            this.special = DFA264_special;
            this.transition = DFA264_transition;
        }
        public String getDescription() {
            return "1043:1: formalParameter : ( Identifier ( LineTerminator )* ( typeInformation )? ( LineTerminator )* ( defaultArgumentValue )? | '...' ( LineTerminator )* Identifier | Identifier ( LineTerminator )* '...' );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA267_eotS =
        "\4\uffff";
    static final String DFA267_eofS =
        "\4\uffff";
    static final String DFA267_minS =
        "\2\4\2\uffff";
    static final String DFA267_maxS =
        "\2\u0081\2\uffff";
    static final String DFA267_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA267_specialS =
        "\4\uffff}>";
    static final String[] DFA267_transitionS = {
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\3\3\1\uffff\1\3\2\uffff"+
            "\1\3\1\2\1\uffff\1\3\2\uffff\12\3\43\uffff\4\3\1\uffff\10\3"+
            "\2\uffff\2\3\2\uffff\1\3\4\uffff\1\3\12\uffff\1\3\1\uffff\1"+
            "\3",
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\3\3\1\uffff\1\3\2\uffff"+
            "\1\3\1\2\1\uffff\1\3\2\uffff\12\3\43\uffff\4\3\1\uffff\10\3"+
            "\2\uffff\2\3\2\uffff\1\3\4\uffff\1\3\12\uffff\1\3\1\uffff\1"+
            "\3",
            "",
            ""
    };

    static final short[] DFA267_eot = DFA.unpackEncodedString(DFA267_eotS);
    static final short[] DFA267_eof = DFA.unpackEncodedString(DFA267_eofS);
    static final char[] DFA267_min = DFA.unpackEncodedStringToUnsignedChars(DFA267_minS);
    static final char[] DFA267_max = DFA.unpackEncodedStringToUnsignedChars(DFA267_maxS);
    static final short[] DFA267_accept = DFA.unpackEncodedString(DFA267_acceptS);
    static final short[] DFA267_special = DFA.unpackEncodedString(DFA267_specialS);
    static final short[][] DFA267_transition;

    static {
        int numStates = DFA267_transitionS.length;
        DFA267_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA267_transition[i] = DFA.unpackEncodedString(DFA267_transitionS[i]);
        }
    }

    class DFA267 extends DFA {

        public DFA267(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 267;
            this.eot = DFA267_eot;
            this.eof = DFA267_eof;
            this.min = DFA267_min;
            this.max = DFA267_max;
            this.accept = DFA267_accept;
            this.special = DFA267_special;
            this.transition = DFA267_transition;
        }
        public String getDescription() {
            return "()* loopback of 1050:4: ( ( LineTerminator )* sourceElement ( LineTerminator )* )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA268_eotS =
        "\34\uffff";
    static final String DFA268_eofS =
        "\34\uffff";
    static final String DFA268_minS =
        "\1\13\1\0\32\uffff";
    static final String DFA268_maxS =
        "\1\u0081\1\0\32\uffff";
    static final String DFA268_acceptS =
        "\2\uffff\1\2\30\uffff\1\1";
    static final String DFA268_specialS =
        "\1\uffff\1\0\32\uffff}>";
    static final String[] DFA268_transitionS = {
            "\1\2\5\uffff\4\2\15\uffff\3\2\1\uffff\1\2\2\uffff\1\2\2\uffff"+
            "\1\2\2\uffff\12\2\43\uffff\4\2\1\uffff\10\2\2\uffff\2\2\2\uffff"+
            "\1\1\4\uffff\1\2\12\uffff\1\2\1\uffff\1\2",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA268_eot = DFA.unpackEncodedString(DFA268_eotS);
    static final short[] DFA268_eof = DFA.unpackEncodedString(DFA268_eofS);
    static final char[] DFA268_min = DFA.unpackEncodedStringToUnsignedChars(DFA268_minS);
    static final char[] DFA268_max = DFA.unpackEncodedStringToUnsignedChars(DFA268_maxS);
    static final short[] DFA268_accept = DFA.unpackEncodedString(DFA268_acceptS);
    static final short[] DFA268_special = DFA.unpackEncodedString(DFA268_specialS);
    static final short[][] DFA268_transition;

    static {
        int numStates = DFA268_transitionS.length;
        DFA268_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA268_transition[i] = DFA.unpackEncodedString(DFA268_transitionS[i]);
        }
    }

    class DFA268 extends DFA {

        public DFA268(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 268;
            this.eot = DFA268_eot;
            this.eof = DFA268_eof;
            this.min = DFA268_min;
            this.max = DFA268_max;
            this.accept = DFA268_accept;
            this.special = DFA268_special;
            this.transition = DFA268_transition;
        }
        public String getDescription() {
            return "1053:1: sourceElement : ( functionDeclaration | statement );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA268_1 = input.LA(1);

                         
                        int index268_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred346_AS3()) ) {s = 27;}

                        else if ( (true) ) {s = 2;}

                         
                        input.seek(index268_1);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 268, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA276_eotS =
        "\4\uffff";
    static final String DFA276_eofS =
        "\4\uffff";
    static final String DFA276_minS =
        "\2\4\2\uffff";
    static final String DFA276_maxS =
        "\2\u0081\2\uffff";
    static final String DFA276_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA276_specialS =
        "\4\uffff}>";
    static final String[] DFA276_transitionS = {
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\3\3\1\uffff\1\3\2\uffff"+
            "\1\3\1\2\1\uffff\1\3\2\uffff\12\3\43\uffff\4\3\1\uffff\10\3"+
            "\2\uffff\2\3\2\uffff\1\3\4\uffff\1\3\1\uffff\3\3\6\uffff\1\3"+
            "\1\uffff\1\3",
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\3\3\1\uffff\1\3\2\uffff"+
            "\1\3\1\2\1\uffff\1\3\2\uffff\12\3\43\uffff\4\3\1\uffff\10\3"+
            "\2\uffff\2\3\2\uffff\1\3\4\uffff\1\3\1\uffff\3\3\6\uffff\1\3"+
            "\1\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA276_eot = DFA.unpackEncodedString(DFA276_eotS);
    static final short[] DFA276_eof = DFA.unpackEncodedString(DFA276_eofS);
    static final char[] DFA276_min = DFA.unpackEncodedStringToUnsignedChars(DFA276_minS);
    static final char[] DFA276_max = DFA.unpackEncodedStringToUnsignedChars(DFA276_maxS);
    static final short[] DFA276_accept = DFA.unpackEncodedString(DFA276_acceptS);
    static final short[] DFA276_special = DFA.unpackEncodedString(DFA276_specialS);
    static final short[][] DFA276_transition;

    static {
        int numStates = DFA276_transitionS.length;
        DFA276_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA276_transition[i] = DFA.unpackEncodedString(DFA276_transitionS[i]);
        }
    }

    class DFA276 extends DFA {

        public DFA276(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 276;
            this.eot = DFA276_eot;
            this.eof = DFA276_eof;
            this.min = DFA276_min;
            this.max = DFA276_max;
            this.accept = DFA276_accept;
            this.special = DFA276_special;
            this.transition = DFA276_transition;
        }
        public String getDescription() {
            return "()* loopback of 1068:4: ( ( LineTerminator )* packageElement ( LineTerminator )* )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA277_eotS =
        "\12\uffff";
    static final String DFA277_eofS =
        "\12\uffff";
    static final String DFA277_minS =
        "\4\4\1\uffff\2\4\2\uffff\1\4";
    static final String DFA277_maxS =
        "\1\u0081\2\170\1\172\1\uffff\2\172\2\uffff\1\172";
    static final String DFA277_acceptS =
        "\4\uffff\1\3\2\uffff\1\2\1\1\1\uffff";
    static final String DFA277_specialS =
        "\12\uffff}>";
    static final String[] DFA277_transitionS = {
            "\1\2\6\uffff\1\4\5\uffff\4\4\15\uffff\3\4\1\uffff\1\4\2\uffff"+
            "\1\4\2\uffff\1\4\2\uffff\12\4\43\uffff\4\4\1\uffff\10\4\2\uffff"+
            "\2\4\2\uffff\1\4\4\uffff\1\4\1\uffff\1\1\2\3\6\uffff\1\4\1\uffff"+
            "\1\4",
            "\1\2\162\uffff\2\3",
            "\1\2\162\uffff\2\3",
            "\1\5\161\uffff\1\6\2\uffff\1\10\1\7",
            "",
            "\1\5\161\uffff\1\6\2\uffff\1\10\1\7",
            "\1\11\164\uffff\1\10\1\7",
            "",
            "",
            "\1\11\164\uffff\1\10\1\7"
    };

    static final short[] DFA277_eot = DFA.unpackEncodedString(DFA277_eotS);
    static final short[] DFA277_eof = DFA.unpackEncodedString(DFA277_eofS);
    static final char[] DFA277_min = DFA.unpackEncodedStringToUnsignedChars(DFA277_minS);
    static final char[] DFA277_max = DFA.unpackEncodedStringToUnsignedChars(DFA277_maxS);
    static final short[] DFA277_accept = DFA.unpackEncodedString(DFA277_acceptS);
    static final short[] DFA277_special = DFA.unpackEncodedString(DFA277_specialS);
    static final short[][] DFA277_transition;

    static {
        int numStates = DFA277_transitionS.length;
        DFA277_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA277_transition[i] = DFA.unpackEncodedString(DFA277_transitionS[i]);
        }
    }

    class DFA277 extends DFA {

        public DFA277(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 277;
            this.eot = DFA277_eot;
            this.eof = DFA277_eof;
            this.min = DFA277_min;
            this.max = DFA277_max;
            this.accept = DFA277_accept;
            this.special = DFA277_special;
            this.transition = DFA277_transition;
        }
        public String getDescription() {
            return "1071:1: packageElement : ( classDeclaration | interfaceDeclaration | statement );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA310_eotS =
        "\4\uffff";
    static final String DFA310_eofS =
        "\1\2\3\uffff";
    static final String DFA310_minS =
        "\2\4\2\uffff";
    static final String DFA310_maxS =
        "\2\51\2\uffff";
    static final String DFA310_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA310_specialS =
        "\4\uffff}>";
    static final String[] DFA310_transitionS = {
            "\1\1\42\uffff\1\3\1\uffff\1\2",
            "\1\1\42\uffff\1\3\1\uffff\1\2",
            "",
            ""
    };

    static final short[] DFA310_eot = DFA.unpackEncodedString(DFA310_eotS);
    static final short[] DFA310_eof = DFA.unpackEncodedString(DFA310_eofS);
    static final char[] DFA310_min = DFA.unpackEncodedStringToUnsignedChars(DFA310_minS);
    static final char[] DFA310_max = DFA.unpackEncodedStringToUnsignedChars(DFA310_maxS);
    static final short[] DFA310_accept = DFA.unpackEncodedString(DFA310_acceptS);
    static final short[] DFA310_special = DFA.unpackEncodedString(DFA310_specialS);
    static final short[][] DFA310_transition;

    static {
        int numStates = DFA310_transitionS.length;
        DFA310_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA310_transition[i] = DFA.unpackEncodedString(DFA310_transitionS[i]);
        }
    }

    class DFA310 extends DFA {

        public DFA310(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 310;
            this.eot = DFA310_eot;
            this.eof = DFA310_eof;
            this.min = DFA310_min;
            this.max = DFA310_max;
            this.accept = DFA310_accept;
            this.special = DFA310_special;
            this.transition = DFA310_transition;
        }
        public String getDescription() {
            return "()* loopback of 1110:47: ( ( LineTerminator )* ',' ( LineTerminator )* qualifiedName )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA313_eotS =
        "\4\uffff";
    static final String DFA313_eofS =
        "\4\uffff";
    static final String DFA313_minS =
        "\2\4\2\uffff";
    static final String DFA313_maxS =
        "\2\u0083\2\uffff";
    static final String DFA313_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA313_specialS =
        "\4\uffff}>";
    static final String[] DFA313_transitionS = {
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\3\3\1\uffff\1\3\2\uffff"+
            "\1\3\1\2\1\uffff\1\3\2\uffff\12\3\43\uffff\4\3\1\uffff\10\3"+
            "\2\uffff\2\3\2\uffff\1\3\4\uffff\1\3\2\uffff\2\3\4\uffff\3\3"+
            "\1\uffff\3\3",
            "\1\1\6\uffff\1\3\5\uffff\4\3\15\uffff\3\3\1\uffff\1\3\2\uffff"+
            "\1\3\1\2\1\uffff\1\3\2\uffff\12\3\43\uffff\4\3\1\uffff\10\3"+
            "\2\uffff\2\3\2\uffff\1\3\4\uffff\1\3\2\uffff\2\3\4\uffff\3\3"+
            "\1\uffff\3\3",
            "",
            ""
    };

    static final short[] DFA313_eot = DFA.unpackEncodedString(DFA313_eotS);
    static final short[] DFA313_eof = DFA.unpackEncodedString(DFA313_eofS);
    static final char[] DFA313_min = DFA.unpackEncodedStringToUnsignedChars(DFA313_minS);
    static final char[] DFA313_max = DFA.unpackEncodedStringToUnsignedChars(DFA313_maxS);
    static final short[] DFA313_accept = DFA.unpackEncodedString(DFA313_acceptS);
    static final short[] DFA313_special = DFA.unpackEncodedString(DFA313_specialS);
    static final short[][] DFA313_transition;

    static {
        int numStates = DFA313_transitionS.length;
        DFA313_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA313_transition[i] = DFA.unpackEncodedString(DFA313_transitionS[i]);
        }
    }

    class DFA313 extends DFA {

        public DFA313(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 313;
            this.eot = DFA313_eot;
            this.eof = DFA313_eof;
            this.min = DFA313_min;
            this.max = DFA313_max;
            this.accept = DFA313_accept;
            this.special = DFA313_special;
            this.transition = DFA313_transition;
        }
        public String getDescription() {
            return "()* loopback of 1114:4: ( ( LineTerminator )* classElement ( LineTerminator )* )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
    static final String DFA327_eotS =
        "\13\uffff";
    static final String DFA327_eofS =
        "\13\uffff";
    static final String DFA327_minS =
        "\1\4\1\uffff\7\0\2\uffff";
    static final String DFA327_maxS =
        "\1\u0083\1\uffff\7\0\2\uffff";
    static final String DFA327_acceptS =
        "\1\uffff\1\1\7\uffff\1\2\1\uffff";
    static final String DFA327_specialS =
        "\2\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\2\uffff}>";
    static final String[] DFA327_transitionS = {
            "\1\2\6\uffff\1\7\120\uffff\2\11\21\uffff\1\10\7\uffff\1\3\1"+
            "\6\4\uffff\1\1\1\11\3\uffff\1\4\1\5",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            ""
    };

    static final short[] DFA327_eot = DFA.unpackEncodedString(DFA327_eotS);
    static final short[] DFA327_eof = DFA.unpackEncodedString(DFA327_eofS);
    static final char[] DFA327_min = DFA.unpackEncodedStringToUnsignedChars(DFA327_minS);
    static final char[] DFA327_max = DFA.unpackEncodedStringToUnsignedChars(DFA327_maxS);
    static final short[] DFA327_accept = DFA.unpackEncodedString(DFA327_acceptS);
    static final short[] DFA327_special = DFA.unpackEncodedString(DFA327_specialS);
    static final short[][] DFA327_transition;

    static {
        int numStates = DFA327_transitionS.length;
        DFA327_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA327_transition[i] = DFA.unpackEncodedString(DFA327_transitionS[i]);
        }
    }

    class DFA327 extends DFA {

        public DFA327(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 327;
            this.eot = DFA327_eot;
            this.eof = DFA327_eof;
            this.min = DFA327_min;
            this.max = DFA327_max;
            this.accept = DFA327_accept;
            this.special = DFA327_special;
            this.transition = DFA327_transition;
        }
        public String getDescription() {
            return "1117:1: classMember : ( ( 'override' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'override' )? ( LineTerminator )* functionDeclaration | ( 'static' )? ( LineTerminator )* ( namespace )? ( LineTerminator )* ( 'static' )? ( LineTerminator )* ( functionDeclaration | variableStatement ) );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA327_2 = input.LA(1);

                         
                        int index327_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred401_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index327_2);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA327_3 = input.LA(1);

                         
                        int index327_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred401_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index327_3);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA327_4 = input.LA(1);

                         
                        int index327_4 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred401_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index327_4);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA327_5 = input.LA(1);

                         
                        int index327_5 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred401_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index327_5);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA327_6 = input.LA(1);

                         
                        int index327_6 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred401_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index327_6);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA327_7 = input.LA(1);

                         
                        int index327_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred401_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index327_7);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA327_8 = input.LA(1);

                         
                        int index327_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred401_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 9;}

                         
                        input.seek(index327_8);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 327, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA328_eotS =
        "\42\uffff";
    static final String DFA328_eofS =
        "\42\uffff";
    static final String DFA328_minS =
        "\1\4\6\uffff\2\0\1\uffff\1\0\27\uffff";
    static final String DFA328_maxS =
        "\1\u0083\6\uffff\2\0\1\uffff\1\0\27\uffff";
    static final String DFA328_acceptS =
        "\1\uffff\1\1\11\uffff\1\2\26\uffff";
    static final String DFA328_specialS =
        "\7\uffff\1\0\1\1\1\uffff\1\2\27\uffff}>";
    static final String[] DFA328_transitionS = {
            "\1\1\6\uffff\1\7\5\uffff\4\13\15\uffff\3\13\1\uffff\1\13\2"+
            "\uffff\1\13\2\uffff\1\13\2\uffff\12\13\43\uffff\2\12\2\13\1"+
            "\uffff\10\13\2\uffff\2\13\2\uffff\1\10\4\uffff\1\13\2\uffff"+
            "\2\1\4\uffff\2\1\1\13\1\uffff\1\13\2\1",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] DFA328_eot = DFA.unpackEncodedString(DFA328_eotS);
    static final short[] DFA328_eof = DFA.unpackEncodedString(DFA328_eofS);
    static final char[] DFA328_min = DFA.unpackEncodedStringToUnsignedChars(DFA328_minS);
    static final char[] DFA328_max = DFA.unpackEncodedStringToUnsignedChars(DFA328_maxS);
    static final short[] DFA328_accept = DFA.unpackEncodedString(DFA328_acceptS);
    static final short[] DFA328_special = DFA.unpackEncodedString(DFA328_specialS);
    static final short[][] DFA328_transition;

    static {
        int numStates = DFA328_transitionS.length;
        DFA328_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA328_transition[i] = DFA.unpackEncodedString(DFA328_transitionS[i]);
        }
    }

    class DFA328 extends DFA {

        public DFA328(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 328;
            this.eot = DFA328_eot;
            this.eof = DFA328_eof;
            this.min = DFA328_min;
            this.max = DFA328_max;
            this.accept = DFA328_accept;
            this.special = DFA328_special;
            this.transition = DFA328_transition;
        }
        public String getDescription() {
            return "1122:1: classElement : ( classMember | statement );";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA328_7 = input.LA(1);

                         
                        int index328_7 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred409_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index328_7);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA328_8 = input.LA(1);

                         
                        int index328_8 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred409_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index328_8);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA328_10 = input.LA(1);

                         
                        int index328_10 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred409_AS3()) ) {s = 1;}

                        else if ( (true) ) {s = 11;}

                         
                        input.seek(index328_10);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 328, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String DFA331_eotS =
        "\4\uffff";
    static final String DFA331_eofS =
        "\4\uffff";
    static final String DFA331_minS =
        "\2\4\2\uffff";
    static final String DFA331_maxS =
        "\2\157\2\uffff";
    static final String DFA331_acceptS =
        "\2\uffff\1\2\1\1";
    static final String DFA331_specialS =
        "\4\uffff}>";
    static final String[] DFA331_transitionS = {
            "\1\1\45\uffff\1\2\104\uffff\1\3",
            "\1\1\45\uffff\1\2\104\uffff\1\3",
            "",
            ""
    };

    static final short[] DFA331_eot = DFA.unpackEncodedString(DFA331_eotS);
    static final short[] DFA331_eof = DFA.unpackEncodedString(DFA331_eofS);
    static final char[] DFA331_min = DFA.unpackEncodedStringToUnsignedChars(DFA331_minS);
    static final char[] DFA331_max = DFA.unpackEncodedStringToUnsignedChars(DFA331_maxS);
    static final short[] DFA331_accept = DFA.unpackEncodedString(DFA331_acceptS);
    static final short[] DFA331_special = DFA.unpackEncodedString(DFA331_specialS);
    static final short[][] DFA331_transition;

    static {
        int numStates = DFA331_transitionS.length;
        DFA331_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA331_transition[i] = DFA.unpackEncodedString(DFA331_transitionS[i]);
        }
    }

    class DFA331 extends DFA {

        public DFA331(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 331;
            this.eot = DFA331_eot;
            this.eof = DFA331_eof;
            this.min = DFA331_min;
            this.max = DFA331_max;
            this.accept = DFA331_accept;
            this.special = DFA331_special;
            this.transition = DFA331_transition;
        }
        public String getDescription() {
            return "()* loopback of 1128:4: ( ( LineTerminator )* interfaceElement ( LineTerminator )* )*";
        }
        public void error(NoViableAltException nvae) {
            dbg.recognitionException(nvae);
        }
    }
 

    public static final BitSet FOLLOW_LineTerminator_in_compilationUnit45 = new BitSet(new long[]{0x0000000000000010L,0x0008000000000000L});
    public static final BitSet FOLLOW_packageDeclaration_in_compilationUnit48 = new BitSet(new long[]{0x0000000000000010L,0x0640000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_compilationUnit50 = new BitSet(new long[]{0x0000000000000010L,0x0640000000000000L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_compilationUnit54 = new BitSet(new long[]{0x0000000000000010L,0x0640000000000000L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_compilationUnit56 = new BitSet(new long[]{0x0000000000000010L,0x0640000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_compilationUnit60 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_EOF_in_compilationUnit63 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_literal0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_34_in_primaryExpression3521 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_35_in_primaryExpression3526 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_primaryExpression3531 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedName_in_primaryExpression3536 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_literal_in_primaryExpression3541 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_arrayLiteral_in_primaryExpression3546 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_objectLiteral_in_primaryExpression3551 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_36_in_primaryExpression3556 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_primaryExpression3559 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_primaryExpression3562 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_primaryExpression3564 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_primaryExpression3567 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_38_in_arrayLiteral3579 = new BitSet(new long[]{0x01FF93DC001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_arrayLiteral3581 = new BitSet(new long[]{0x01FF93DC001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_arrayLiteral3584 = new BitSet(new long[]{0x0000018000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_arrayLiteral3588 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_arrayLiteral3591 = new BitSet(new long[]{0x01FF93DC001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_arrayLiteral3594 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_arrayLiteral3597 = new BitSet(new long[]{0x0000018000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_arrayLiteral3603 = new BitSet(new long[]{0x0000010000000010L});
    public static final BitSet FOLLOW_40_in_arrayLiteral3606 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_41_in_objectLiteral3618 = new BitSet(new long[]{0x0000040000180810L});
    public static final BitSet FOLLOW_LineTerminator_in_objectLiteral3620 = new BitSet(new long[]{0x0000040000180810L});
    public static final BitSet FOLLOW_propertyNameAndValue_in_objectLiteral3624 = new BitSet(new long[]{0x0000048000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_objectLiteral3627 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_objectLiteral3630 = new BitSet(new long[]{0x0000000000180810L});
    public static final BitSet FOLLOW_LineTerminator_in_objectLiteral3632 = new BitSet(new long[]{0x0000000000180810L});
    public static final BitSet FOLLOW_propertyNameAndValue_in_objectLiteral3635 = new BitSet(new long[]{0x0000048000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_objectLiteral3639 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_42_in_objectLiteral3644 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyName_in_propertyNameAndValue3655 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_propertyNameAndValue3657 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_43_in_propertyNameAndValue3660 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_propertyNameAndValue3662 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_propertyNameAndValue3665 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_propertyName0 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_primaryExpression_in_memberExpression3699 = new BitSet(new long[]{0x0000204000000012L});
    public static final BitSet FOLLOW_functionExpression_in_memberExpression3703 = new BitSet(new long[]{0x0000204000000012L});
    public static final BitSet FOLLOW_44_in_memberExpression3707 = new BitSet(new long[]{0x0000125C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_memberExpression3709 = new BitSet(new long[]{0x0000125C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_memberExpression_in_memberExpression3712 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_memberExpression3714 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_argumentList_in_memberExpression3717 = new BitSet(new long[]{0x0000204000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_memberExpression3721 = new BitSet(new long[]{0x0000204000000010L});
    public static final BitSet FOLLOW_memberExpressionSuffix_in_memberExpression3724 = new BitSet(new long[]{0x0000204000000012L});
    public static final BitSet FOLLOW_indexSuffix_in_memberExpressionSuffix3738 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyReferenceSuffix_in_memberExpressionSuffix3743 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberExpression_in_newExpression3755 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_44_in_newExpression3760 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_newExpression3762 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_newExpression_in_newExpression3765 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberExpression_in_callExpression3777 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_callExpression3779 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_argumentList_in_callExpression3782 = new BitSet(new long[]{0x0000205000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_callExpression3785 = new BitSet(new long[]{0x0000205000000010L});
    public static final BitSet FOLLOW_callExpressionSuffix_in_callExpression3788 = new BitSet(new long[]{0x0000205000000012L});
    public static final BitSet FOLLOW_argumentList_in_callExpressionSuffix3802 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_indexSuffix_in_callExpressionSuffix3807 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_propertyReferenceSuffix_in_callExpressionSuffix3812 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_38_in_indexSuffix3823 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_indexSuffix3825 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_indexSuffix3828 = new BitSet(new long[]{0x0000010000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_indexSuffix3830 = new BitSet(new long[]{0x0000010000000010L});
    public static final BitSet FOLLOW_40_in_indexSuffix3833 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_45_in_propertyReferenceSuffix3846 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_propertyReferenceSuffix3848 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_Identifier_in_propertyReferenceSuffix3852 = new BitSet(new long[]{0x0000400000000000L});
    public static final BitSet FOLLOW_46_in_propertyReferenceSuffix3854 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_propertyReferenceSuffix3856 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_Identifier_in_propertyReferenceSuffix3861 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_36_in_argumentList3873 = new BitSet(new long[]{0x01FF927C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_argumentList3876 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_argumentList3879 = new BitSet(new long[]{0x000000A000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_argumentList3882 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_argumentList3885 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_argumentList3887 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_argumentList3890 = new BitSet(new long[]{0x000000A000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_argumentList3896 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_argumentList3899 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_callExpression_in_leftHandSideExpression3911 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_newExpression_in_leftHandSideExpression3916 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_postfixExpression3927 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_postfixExpression3929 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_postfixExpression3934 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_postfixExpression3936 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_postfixExpression3941 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_postfixExpression_in_unaryExpression3952 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_unaryExpression3957 = new BitSet(new long[]{0x01FF925C001E0800L,0x0000800000000000L});
    public static final BitSet FOLLOW_unaryExpression_in_unaryExpression3997 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4008 = new BitSet(new long[]{0x0E00000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_multiplicativeExpression4011 = new BitSet(new long[]{0x0E00000000000010L});
    public static final BitSet FOLLOW_set_in_multiplicativeExpression4014 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_multiplicativeExpression4026 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4029 = new BitSet(new long[]{0x0E00000000000012L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4042 = new BitSet(new long[]{0x0060000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_additiveExpression4045 = new BitSet(new long[]{0x0060000000000010L});
    public static final BitSet FOLLOW_set_in_additiveExpression4048 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_additiveExpression4056 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4059 = new BitSet(new long[]{0x0060000000000012L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression4072 = new BitSet(new long[]{0x7000000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_shiftExpression4075 = new BitSet(new long[]{0x7000000000000010L});
    public static final BitSet FOLLOW_set_in_shiftExpression4078 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_shiftExpression4090 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_additiveExpression_in_shiftExpression4093 = new BitSet(new long[]{0x7000000000000012L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression4106 = new BitSet(new long[]{0x8000000000000012L,0x000000000000003FL});
    public static final BitSet FOLLOW_LineTerminator_in_relationalExpression4109 = new BitSet(new long[]{0x8000000000000010L,0x000000000000003FL});
    public static final BitSet FOLLOW_set_in_relationalExpression4112 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_relationalExpression4140 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpression4143 = new BitSet(new long[]{0x8000000000000012L,0x000000000000003FL});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpressionNoIn4157 = new BitSet(new long[]{0x8000000000000012L,0x000000000000001FL});
    public static final BitSet FOLLOW_LineTerminator_in_relationalExpressionNoIn4160 = new BitSet(new long[]{0x8000000000000010L,0x000000000000001FL});
    public static final BitSet FOLLOW_set_in_relationalExpressionNoIn4163 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_relationalExpressionNoIn4187 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_shiftExpression_in_relationalExpressionNoIn4190 = new BitSet(new long[]{0x8000000000000012L,0x000000000000001FL});
    public static final BitSet FOLLOW_relationalExpression_in_equalityExpression4204 = new BitSet(new long[]{0x0000000000000012L,0x00000000000003C0L});
    public static final BitSet FOLLOW_LineTerminator_in_equalityExpression4207 = new BitSet(new long[]{0x0000000000000010L,0x00000000000003C0L});
    public static final BitSet FOLLOW_set_in_equalityExpression4210 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_equalityExpression4226 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_relationalExpression_in_equalityExpression4229 = new BitSet(new long[]{0x0000000000000012L,0x00000000000003C0L});
    public static final BitSet FOLLOW_relationalExpressionNoIn_in_equalityExpressionNoIn4242 = new BitSet(new long[]{0x0000000000000012L,0x00000000000003C0L});
    public static final BitSet FOLLOW_LineTerminator_in_equalityExpressionNoIn4245 = new BitSet(new long[]{0x0000000000000010L,0x00000000000003C0L});
    public static final BitSet FOLLOW_set_in_equalityExpressionNoIn4248 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_equalityExpressionNoIn4264 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_relationalExpressionNoIn_in_equalityExpressionNoIn4267 = new BitSet(new long[]{0x0000000000000012L,0x00000000000003C0L});
    public static final BitSet FOLLOW_equalityExpression_in_bitwiseANDExpression4280 = new BitSet(new long[]{0x0000000000000012L,0x0000000000000400L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseANDExpression4283 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000400L});
    public static final BitSet FOLLOW_74_in_bitwiseANDExpression4286 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseANDExpression4288 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_equalityExpression_in_bitwiseANDExpression4291 = new BitSet(new long[]{0x0000000000000012L,0x0000000000000400L});
    public static final BitSet FOLLOW_equalityExpressionNoIn_in_bitwiseANDExpressionNoIn4305 = new BitSet(new long[]{0x0000000000000012L,0x0000000000000400L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseANDExpressionNoIn4308 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000400L});
    public static final BitSet FOLLOW_74_in_bitwiseANDExpressionNoIn4311 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseANDExpressionNoIn4313 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_equalityExpressionNoIn_in_bitwiseANDExpressionNoIn4316 = new BitSet(new long[]{0x0000000000000012L,0x0000000000000400L});
    public static final BitSet FOLLOW_bitwiseANDExpression_in_bitwiseXORExpression4329 = new BitSet(new long[]{0x0000000000000012L,0x0000000000000800L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseXORExpression4332 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000800L});
    public static final BitSet FOLLOW_75_in_bitwiseXORExpression4335 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseXORExpression4337 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_bitwiseANDExpression_in_bitwiseXORExpression4340 = new BitSet(new long[]{0x0000000000000012L,0x0000000000000800L});
    public static final BitSet FOLLOW_bitwiseANDExpressionNoIn_in_bitwiseXORExpressionNoIn4354 = new BitSet(new long[]{0x0000000000000012L,0x0000000000000800L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseXORExpressionNoIn4357 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000800L});
    public static final BitSet FOLLOW_75_in_bitwiseXORExpressionNoIn4360 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseXORExpressionNoIn4362 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_bitwiseANDExpressionNoIn_in_bitwiseXORExpressionNoIn4365 = new BitSet(new long[]{0x0000000000000012L,0x0000000000000800L});
    public static final BitSet FOLLOW_bitwiseXORExpression_in_bitwiseORExpression4379 = new BitSet(new long[]{0x0000000000000012L,0x0000000000001000L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseORExpression4382 = new BitSet(new long[]{0x0000000000000010L,0x0000000000001000L});
    public static final BitSet FOLLOW_76_in_bitwiseORExpression4385 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseORExpression4387 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_bitwiseXORExpression_in_bitwiseORExpression4390 = new BitSet(new long[]{0x0000000000000012L,0x0000000000001000L});
    public static final BitSet FOLLOW_bitwiseXORExpressionNoIn_in_bitwiseORExpressionNoIn4404 = new BitSet(new long[]{0x0000000000000012L,0x0000000000001000L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseORExpressionNoIn4407 = new BitSet(new long[]{0x0000000000000010L,0x0000000000001000L});
    public static final BitSet FOLLOW_76_in_bitwiseORExpressionNoIn4410 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_bitwiseORExpressionNoIn4412 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_bitwiseXORExpressionNoIn_in_bitwiseORExpressionNoIn4415 = new BitSet(new long[]{0x0000000000000012L,0x0000000000001000L});
    public static final BitSet FOLLOW_bitwiseORExpression_in_logicalANDExpression4429 = new BitSet(new long[]{0x0000000000000012L,0x0000000000002000L});
    public static final BitSet FOLLOW_LineTerminator_in_logicalANDExpression4432 = new BitSet(new long[]{0x0000000000000010L,0x0000000000002000L});
    public static final BitSet FOLLOW_77_in_logicalANDExpression4435 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_logicalANDExpression4437 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_bitwiseORExpression_in_logicalANDExpression4440 = new BitSet(new long[]{0x0000000000000012L,0x0000000000002000L});
    public static final BitSet FOLLOW_bitwiseORExpressionNoIn_in_logicalANDExpressionNoIn4454 = new BitSet(new long[]{0x0000000000000012L,0x0000000000002000L});
    public static final BitSet FOLLOW_LineTerminator_in_logicalANDExpressionNoIn4457 = new BitSet(new long[]{0x0000000000000010L,0x0000000000002000L});
    public static final BitSet FOLLOW_77_in_logicalANDExpressionNoIn4460 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_logicalANDExpressionNoIn4462 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_bitwiseORExpressionNoIn_in_logicalANDExpressionNoIn4465 = new BitSet(new long[]{0x0000000000000012L,0x0000000000002000L});
    public static final BitSet FOLLOW_logicalANDExpression_in_logicalORExpression4479 = new BitSet(new long[]{0x0000000000000012L,0x0000000000004000L});
    public static final BitSet FOLLOW_LineTerminator_in_logicalORExpression4482 = new BitSet(new long[]{0x0000000000000010L,0x0000000000004000L});
    public static final BitSet FOLLOW_78_in_logicalORExpression4485 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_logicalORExpression4487 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_logicalANDExpression_in_logicalORExpression4490 = new BitSet(new long[]{0x0000000000000012L,0x0000000000004000L});
    public static final BitSet FOLLOW_logicalANDExpressionNoIn_in_logicalORExpressionNoIn4503 = new BitSet(new long[]{0x0000000000000012L,0x0000000000004000L});
    public static final BitSet FOLLOW_LineTerminator_in_logicalORExpressionNoIn4506 = new BitSet(new long[]{0x0000000000000010L,0x0000000000004000L});
    public static final BitSet FOLLOW_78_in_logicalORExpressionNoIn4509 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_logicalORExpressionNoIn4511 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_logicalANDExpressionNoIn_in_logicalORExpressionNoIn4514 = new BitSet(new long[]{0x0000000000000012L,0x0000000000004000L});
    public static final BitSet FOLLOW_logicalORExpression_in_conditionalExpression4528 = new BitSet(new long[]{0x0000000000000012L,0x0000000000008000L});
    public static final BitSet FOLLOW_LineTerminator_in_conditionalExpression4531 = new BitSet(new long[]{0x0000000000000010L,0x0000000000008000L});
    public static final BitSet FOLLOW_79_in_conditionalExpression4534 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_conditionalExpression4536 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpression4539 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_conditionalExpression4541 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_43_in_conditionalExpression4544 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_conditionalExpression4546 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpression4549 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_logicalORExpressionNoIn_in_conditionalExpressionNoIn4563 = new BitSet(new long[]{0x0000000000000012L,0x0000000000008000L});
    public static final BitSet FOLLOW_LineTerminator_in_conditionalExpressionNoIn4566 = new BitSet(new long[]{0x0000000000000010L,0x0000000000008000L});
    public static final BitSet FOLLOW_79_in_conditionalExpressionNoIn4569 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_conditionalExpressionNoIn4571 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpressionNoIn4574 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_conditionalExpressionNoIn4576 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_43_in_conditionalExpressionNoIn4579 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_conditionalExpressionNoIn4581 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_conditionalExpressionNoIn4584 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_assignmentExpression4597 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_assignmentExpression4602 = new BitSet(new long[]{0x0000000000000010L,0x000000000FFF0000L});
    public static final BitSet FOLLOW_LineTerminator_in_assignmentExpression4604 = new BitSet(new long[]{0x0000000000000010L,0x000000000FFF0000L});
    public static final BitSet FOLLOW_assignmentOperator_in_assignmentExpression4607 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_assignmentExpression4609 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_assignmentExpression4612 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpressionNoIn_in_assignmentExpressionNoIn4624 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_assignmentExpressionNoIn4629 = new BitSet(new long[]{0x0000000000000010L,0x000000000FFF0000L});
    public static final BitSet FOLLOW_LineTerminator_in_assignmentExpressionNoIn4631 = new BitSet(new long[]{0x0000000000000010L,0x000000000FFF0000L});
    public static final BitSet FOLLOW_assignmentOperator_in_assignmentExpressionNoIn4634 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_assignmentExpressionNoIn4636 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_assignmentExpressionNoIn4639 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_assignmentOperator4651 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_assignmentExpression_in_expression4709 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_expression4712 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_expression4715 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_expression4717 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_expression4720 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_expressionNoIn4734 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_expressionNoIn4737 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_expressionNoIn4740 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_expressionNoIn4742 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_expressionNoIn4745 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_blockStatement_in_statement4763 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableStatement_in_statement4768 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_emptyStatement_in_statement4773 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionStatement_in_statement4778 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ifStatement_in_statement4783 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_iterationStatement_in_statement4788 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_continueStatement_in_statement4793 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_breakStatement_in_statement4798 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_returnStatement_in_statement4803 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_withStatement_in_statement4808 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_labelledStatement_in_statement4813 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_switchStatement_in_statement4818 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_throwStatement_in_statement4823 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_tryStatement_in_statement4828 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_useNamespaceStatement_in_statement4833 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_includeStatement_in_statement4838 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_importStatement_in_statement4843 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_metaDataStatement_in_statement4848 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_41_in_blockStatement4859 = new BitSet(new long[]{0x01FF965C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_blockStatement4861 = new BitSet(new long[]{0x01FF965C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statementList_in_blockStatement4864 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_blockStatement4867 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_42_in_blockStatement4870 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_statementList4883 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_statementList4886 = new BitSet(new long[]{0x01FF925C001E0812L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_statementList4888 = new BitSet(new long[]{0x01FF925C001E0812L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_set_in_variableStatement4903 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_variableStatement4911 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_variableDeclarationList_in_variableStatement4914 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_variableStatement4917 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_variableStatement4922 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableDeclaration_in_variableDeclarationList4935 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_variableDeclarationList4938 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_variableDeclarationList4941 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_variableDeclarationList4943 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_variableDeclaration_in_variableDeclarationList4946 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_variableDeclarationNoIn_in_variableDeclarationListNoIn4960 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_variableDeclarationListNoIn4963 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_variableDeclarationListNoIn4966 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_variableDeclarationListNoIn4968 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_variableDeclarationNoIn_in_variableDeclarationListNoIn4971 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_Identifier_in_variableDeclaration4984 = new BitSet(new long[]{0x0000080000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_LineTerminator_in_variableDeclaration4986 = new BitSet(new long[]{0x0000080000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_typeInformation_in_variableDeclaration4989 = new BitSet(new long[]{0x0000000000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_LineTerminator_in_variableDeclaration4992 = new BitSet(new long[]{0x0000000000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_initialiser_in_variableDeclaration4995 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_variableDeclarationNoIn5007 = new BitSet(new long[]{0x0000080000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_LineTerminator_in_variableDeclarationNoIn5009 = new BitSet(new long[]{0x0000080000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_typeInformation_in_variableDeclarationNoIn5012 = new BitSet(new long[]{0x0000000000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_LineTerminator_in_variableDeclarationNoIn5015 = new BitSet(new long[]{0x0000000000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_initialiserNoIn_in_variableDeclarationNoIn5018 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_80_in_initialiser5030 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_initialiser5032 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpression_in_initialiser5035 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_80_in_initialiserNoIn5047 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_initialiserNoIn5049 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_initialiserNoIn5052 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_94_in_emptyStatement5064 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expression_in_expressionStatement5076 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_expressionStatement5079 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_expressionStatement5084 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_95_in_ifStatement5096 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_ifStatement5098 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_36_in_ifStatement5101 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_ifStatement5103 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_ifStatement5106 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_ifStatement5108 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_ifStatement5111 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FFF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_ifStatement5113 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FFF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_ifStatement5116 = new BitSet(new long[]{0x0000000000000012L,0x0000000100000000L});
    public static final BitSet FOLLOW_LineTerminator_in_ifStatement5119 = new BitSet(new long[]{0x0000000000000010L,0x0000000100000000L});
    public static final BitSet FOLLOW_96_in_ifStatement5122 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_ifStatement5124 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_ifStatement5127 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_doWhileStatement_in_iterationStatement5140 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_whileStatement_in_iterationStatement5145 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forStatement_in_iterationStatement5150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forInStatement_in_iterationStatement5155 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_97_in_doWhileStatement5167 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_doWhileStatement5169 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_doWhileStatement5172 = new BitSet(new long[]{0x0000000000000010L,0x0000000400000000L});
    public static final BitSet FOLLOW_LineTerminator_in_doWhileStatement5174 = new BitSet(new long[]{0x0000000000000010L,0x0000000400000000L});
    public static final BitSet FOLLOW_98_in_doWhileStatement5177 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_doWhileStatement5179 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_36_in_doWhileStatement5182 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_doWhileStatement5184 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_37_in_doWhileStatement5186 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_doWhileStatement5189 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_doWhileStatement5194 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_98_in_whileStatement5207 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_whileStatement5209 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_36_in_whileStatement5212 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_whileStatement5214 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_whileStatement5217 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_whileStatement5219 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_whileStatement5222 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_whileStatement5224 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_whileStatement5227 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_99_in_forStatement5239 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatement5241 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_36_in_forStatement5244 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800050000000L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatement5247 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800010000000L});
    public static final BitSet FOLLOW_forStatementInitialiserPart_in_forStatement5250 = new BitSet(new long[]{0x0000000000000010L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatement5254 = new BitSet(new long[]{0x0000000000000010L,0x0000000040000000L});
    public static final BitSet FOLLOW_94_in_forStatement5257 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatement5260 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_forStatement5263 = new BitSet(new long[]{0x0000000000000010L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatement5267 = new BitSet(new long[]{0x0000000000000010L,0x0000000040000000L});
    public static final BitSet FOLLOW_94_in_forStatement5270 = new BitSet(new long[]{0x01FF927C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatement5273 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_forStatement5276 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatement5280 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_forStatement5283 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatement5285 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_forStatement5288 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionNoIn_in_forStatementInitialiserPart5300 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_92_in_forStatementInitialiserPart5305 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_forStatementInitialiserPart5307 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_variableDeclarationListNoIn_in_forStatementInitialiserPart5310 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_99_in_forInStatement5322 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_forInStatement5324 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_36_in_forInStatement5327 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800010000000L});
    public static final BitSet FOLLOW_LineTerminator_in_forInStatement5329 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800010000000L});
    public static final BitSet FOLLOW_forInStatementInitialiserPart_in_forInStatement5332 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000020L});
    public static final BitSet FOLLOW_LineTerminator_in_forInStatement5334 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000020L});
    public static final BitSet FOLLOW_69_in_forInStatement5337 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_forInStatement5339 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_forInStatement5342 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_forInStatement5344 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_forInStatement5347 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_forInStatement5349 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_forInStatement5352 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_forInStatementInitialiserPart5364 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_92_in_forInStatementInitialiserPart5369 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_forInStatementInitialiserPart5371 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_variableDeclarationNoIn_in_forInStatementInitialiserPart5374 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_100_in_continueStatement5385 = new BitSet(new long[]{0x0000000000000812L,0x0000000040000000L});
    public static final BitSet FOLLOW_Identifier_in_continueStatement5387 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_continueStatement5391 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_continueStatement5396 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_101_in_breakStatement5408 = new BitSet(new long[]{0x0000000000000812L,0x0000000040000000L});
    public static final BitSet FOLLOW_Identifier_in_breakStatement5410 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_breakStatement5414 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_breakStatement5419 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_102_in_returnStatement5431 = new BitSet(new long[]{0x01FF925C001E0812L,0x0000800040000000L});
    public static final BitSet FOLLOW_expression_in_returnStatement5433 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_returnStatement5437 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_returnStatement5442 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_103_in_withStatement5455 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_withStatement5457 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_36_in_withStatement5460 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_withStatement5462 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_withStatement5465 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_withStatement5467 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_withStatement5470 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_withStatement5472 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_withStatement5475 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_104_in_switchStatement5487 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_switchStatement5489 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_36_in_switchStatement5492 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_switchStatement5494 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_switchStatement5497 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_switchStatement5499 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_switchStatement5502 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_switchStatement5504 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_caseBlock_in_switchStatement5507 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_41_in_caseBlock5519 = new BitSet(new long[]{0x0000040000000010L,0x0000060000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_caseBlock5522 = new BitSet(new long[]{0x0000000000000010L,0x0000020000000000L});
    public static final BitSet FOLLOW_caseClause_in_caseBlock5525 = new BitSet(new long[]{0x0000040000000010L,0x0000060000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_caseBlock5530 = new BitSet(new long[]{0x0000000000000010L,0x0000040000000000L});
    public static final BitSet FOLLOW_defaultClause_in_caseBlock5533 = new BitSet(new long[]{0x0000040000000010L,0x0000060000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_caseBlock5536 = new BitSet(new long[]{0x0000040000000010L,0x0000060000000000L});
    public static final BitSet FOLLOW_caseClause_in_caseBlock5539 = new BitSet(new long[]{0x0000040000000010L,0x0000060000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_caseBlock5545 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_42_in_caseBlock5548 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_105_in_caseClause5559 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_caseClause5561 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_caseClause5564 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_caseClause5566 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_43_in_caseClause5569 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_caseClause5571 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statementList_in_caseClause5574 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_106_in_defaultClause5587 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_defaultClause5589 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_43_in_defaultClause5592 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_defaultClause5594 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statementList_in_defaultClause5597 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_labelledStatement5610 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_labelledStatement5612 = new BitSet(new long[]{0x0000080000000010L});
    public static final BitSet FOLLOW_43_in_labelledStatement5615 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_labelledStatement5617 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_labelledStatement5620 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_107_in_throwStatement5632 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_expression_in_throwStatement5634 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_throwStatement5637 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_throwStatement5642 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_108_in_tryStatement5654 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_tryStatement5656 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_blockStatement_in_tryStatement5659 = new BitSet(new long[]{0x0000000000000010L,0x0000600000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_tryStatement5661 = new BitSet(new long[]{0x0000000000000010L,0x0000600000000000L});
    public static final BitSet FOLLOW_finallyClause_in_tryStatement5666 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_tryStatement5668 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_catchClause_in_tryStatement5675 = new BitSet(new long[]{0x0000000000000012L,0x0000600000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_tryStatement5677 = new BitSet(new long[]{0x0000000000000012L,0x0000600000000000L});
    public static final BitSet FOLLOW_finallyClause_in_tryStatement5682 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_109_in_catchClause5703 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_catchClause5705 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_36_in_catchClause5708 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_catchClause5710 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_Identifier_in_catchClause5713 = new BitSet(new long[]{0x0000082000000010L});
    public static final BitSet FOLLOW_typeInformation_in_catchClause5715 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_catchClause5718 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_catchClause5721 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_catchClause5723 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_blockStatement_in_catchClause5726 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_110_in_finallyClause5738 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_finallyClause5740 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_blockStatement_in_finallyClause5743 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_111_in_functionDeclaration5758 = new BitSet(new long[]{0x0000000000000810L,0x0003000000000000L});
    public static final BitSet FOLLOW_set_in_functionDeclaration5760 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_functionDeclaration5767 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_Identifier_in_functionDeclaration5770 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_functionDeclaration5772 = new BitSet(new long[]{0x0000001000000010L});
    public static final BitSet FOLLOW_formalParameterList_in_functionDeclaration5775 = new BitSet(new long[]{0x00000A0000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_functionDeclaration5777 = new BitSet(new long[]{0x00000A0000000010L});
    public static final BitSet FOLLOW_typeInformation_in_functionDeclaration5780 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_functionDeclaration5783 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_41_in_functionDeclaration5786 = new BitSet(new long[]{0x01FF965C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_functionDeclaration5788 = new BitSet(new long[]{0x01FF965C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_sourceElements_in_functionDeclaration5791 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_functionDeclaration5793 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_42_in_functionDeclaration5796 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_111_in_functionExpression5808 = new BitSet(new long[]{0x0000001000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_functionExpression5810 = new BitSet(new long[]{0x0000001000000810L});
    public static final BitSet FOLLOW_Identifier_in_functionExpression5813 = new BitSet(new long[]{0x0000001000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_functionExpression5816 = new BitSet(new long[]{0x0000001000000810L});
    public static final BitSet FOLLOW_formalParameterList_in_functionExpression5819 = new BitSet(new long[]{0x00000A0000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_functionExpression5821 = new BitSet(new long[]{0x00000A0000000010L});
    public static final BitSet FOLLOW_typeInformation_in_functionExpression5824 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_functionExpression5827 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_41_in_functionExpression5830 = new BitSet(new long[]{0x01FF965C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_functionExpression5832 = new BitSet(new long[]{0x01FF965C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_sourceElements_in_functionExpression5835 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_functionExpression5837 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_42_in_functionExpression5840 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_36_in_formalParameterList5851 = new BitSet(new long[]{0x0000002000000810L,0x0004000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_formalParameterList5854 = new BitSet(new long[]{0x0000000000000810L,0x0004000000000000L});
    public static final BitSet FOLLOW_formalParameter_in_formalParameterList5857 = new BitSet(new long[]{0x000000A000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_formalParameterList5860 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_formalParameterList5863 = new BitSet(new long[]{0x0000000000000810L,0x0004000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_formalParameterList5865 = new BitSet(new long[]{0x0000000000000810L,0x0004000000000000L});
    public static final BitSet FOLLOW_formalParameter_in_formalParameterList5868 = new BitSet(new long[]{0x000000A000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_formalParameterList5875 = new BitSet(new long[]{0x0000002000000010L});
    public static final BitSet FOLLOW_37_in_formalParameterList5878 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_formalParameter5890 = new BitSet(new long[]{0x0000080000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_LineTerminator_in_formalParameter5892 = new BitSet(new long[]{0x0000080000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_typeInformation_in_formalParameter5895 = new BitSet(new long[]{0x0000000000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_LineTerminator_in_formalParameter5898 = new BitSet(new long[]{0x0000000000000012L,0x0000000000010000L});
    public static final BitSet FOLLOW_defaultArgumentValue_in_formalParameter5901 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_114_in_formalParameter5907 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_formalParameter5909 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_Identifier_in_formalParameter5912 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_formalParameter5917 = new BitSet(new long[]{0x0000000000000010L,0x0004000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_formalParameter5919 = new BitSet(new long[]{0x0000000000000010L,0x0004000000000000L});
    public static final BitSet FOLLOW_114_in_formalParameter5922 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_sourceElements5936 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_sourceElement_in_sourceElements5939 = new BitSet(new long[]{0x01FF925C001E0812L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_sourceElements5941 = new BitSet(new long[]{0x01FF925C001E0812L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_functionDeclaration_in_sourceElement5955 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_sourceElement5960 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_115_in_packageDeclaration5976 = new BitSet(new long[]{0x0000020000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_packageDeclaration5978 = new BitSet(new long[]{0x0000020000000810L});
    public static final BitSet FOLLOW_qualifiedName_in_packageDeclaration5981 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_packageDeclaration5984 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_41_in_packageDeclaration5987 = new BitSet(new long[]{0x01FF965C001E0810L,0x81D099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_packageDeclaration5989 = new BitSet(new long[]{0x01FF965C001E0810L,0x81D099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_packageElements_in_packageDeclaration5992 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_packageDeclaration5994 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_42_in_packageDeclaration5997 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_packageElements6010 = new BitSet(new long[]{0x01FF925C001E0810L,0x81D099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_packageElement_in_packageElements6013 = new BitSet(new long[]{0x01FF925C001E0812L,0x81D099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_packageElements6015 = new BitSet(new long[]{0x01FF925C001E0812L,0x81D099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_classDeclaration_in_packageElement6029 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_interfaceDeclaration_in_packageElement6034 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_packageElement6039 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_116_in_importStatement6050 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_importStatement6052 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_qualifiedName_in_importStatement6055 = new BitSet(new long[]{0x0000000000000012L,0x0020000040000000L});
    public static final BitSet FOLLOW_117_in_importStatement6057 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_importStatement6061 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_importStatement6066 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_118_in_classDeclaration6078 = new BitSet(new long[]{0x0000000000000010L,0x0180000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_classDeclaration6081 = new BitSet(new long[]{0x0000000000000010L,0x0180000000000000L});
    public static final BitSet FOLLOW_set_in_classDeclaration6084 = new BitSet(new long[]{0x0000000000000010L,0x0240000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_classDeclaration6092 = new BitSet(new long[]{0x0000000000000010L,0x0240000000000000L});
    public static final BitSet FOLLOW_normalClassDeclaration_in_classDeclaration6095 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_118_in_normalClassDeclaration6106 = new BitSet(new long[]{0x0000000000000010L,0x0200000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_normalClassDeclaration6109 = new BitSet(new long[]{0x0000000000000010L,0x0200000000000000L});
    public static final BitSet FOLLOW_121_in_normalClassDeclaration6112 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_normalClassDeclaration6114 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_qualifiedName_in_normalClassDeclaration6117 = new BitSet(new long[]{0x0000020000000010L,0x1800000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_normalClassDeclaration6119 = new BitSet(new long[]{0x0000020000000010L,0x1800000000000000L});
    public static final BitSet FOLLOW_inheritance_in_normalClassDeclaration6122 = new BitSet(new long[]{0x0000020000000010L,0x1000000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_normalClassDeclaration6125 = new BitSet(new long[]{0x0000020000000010L,0x1000000000000000L});
    public static final BitSet FOLLOW_interfaceImplementations_in_normalClassDeclaration6128 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_normalClassDeclaration6131 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_41_in_normalClassDeclaration6134 = new BitSet(new long[]{0x01FF965C001E0810L,0xE19099FEF0000000L,0x000000000000000EL});
    public static final BitSet FOLLOW_LineTerminator_in_normalClassDeclaration6136 = new BitSet(new long[]{0x01FF965C001E0810L,0xE19099FEF0000000L,0x000000000000000EL});
    public static final BitSet FOLLOW_classElements_in_normalClassDeclaration6139 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_normalClassDeclaration6141 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_42_in_normalClassDeclaration6144 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_118_in_interfaceDeclaration6156 = new BitSet(new long[]{0x0000000000000010L,0x0180000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_interfaceDeclaration6159 = new BitSet(new long[]{0x0000000000000010L,0x0180000000000000L});
    public static final BitSet FOLLOW_set_in_interfaceDeclaration6162 = new BitSet(new long[]{0x0000000000000010L,0x0640000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_interfaceDeclaration6170 = new BitSet(new long[]{0x0000000000000010L,0x0640000000000000L});
    public static final BitSet FOLLOW_normalInterfaceDeclaration_in_interfaceDeclaration6173 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_118_in_normalInterfaceDeclaration6185 = new BitSet(new long[]{0x0000000000000010L,0x0400000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_normalInterfaceDeclaration6188 = new BitSet(new long[]{0x0000000000000010L,0x0400000000000000L});
    public static final BitSet FOLLOW_122_in_normalInterfaceDeclaration6191 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_normalInterfaceDeclaration6193 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_qualifiedName_in_normalInterfaceDeclaration6196 = new BitSet(new long[]{0x0000020000000010L,0x0800000000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_normalInterfaceDeclaration6198 = new BitSet(new long[]{0x0000020000000010L,0x0800000000000000L});
    public static final BitSet FOLLOW_inheritance_in_normalInterfaceDeclaration6201 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_normalInterfaceDeclaration6204 = new BitSet(new long[]{0x0000020000000010L});
    public static final BitSet FOLLOW_41_in_normalInterfaceDeclaration6207 = new BitSet(new long[]{0x0000040000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_normalInterfaceDeclaration6209 = new BitSet(new long[]{0x0000040000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_interfaceElements_in_normalInterfaceDeclaration6212 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_normalInterfaceDeclaration6214 = new BitSet(new long[]{0x0000040000000010L});
    public static final BitSet FOLLOW_42_in_normalInterfaceDeclaration6217 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_123_in_inheritance6237 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_inheritance6239 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_qualifiedName_in_inheritance6242 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_124_in_interfaceImplementations6253 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_interfaceImplementations6255 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_qualifiedName_in_interfaceImplementations6258 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_interfaceImplementations6261 = new BitSet(new long[]{0x0000008000000010L});
    public static final BitSet FOLLOW_39_in_interfaceImplementations6264 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_interfaceImplementations6266 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_qualifiedName_in_interfaceImplementations6269 = new BitSet(new long[]{0x0000008000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_classElements6283 = new BitSet(new long[]{0x01FF925C001E0810L,0xE19099FEF0000000L,0x000000000000000EL});
    public static final BitSet FOLLOW_classElement_in_classElements6286 = new BitSet(new long[]{0x01FF925C001E0812L,0xE19099FEF0000000L,0x000000000000000EL});
    public static final BitSet FOLLOW_LineTerminator_in_classElements6288 = new BitSet(new long[]{0x01FF925C001E0812L,0xE19099FEF0000000L,0x000000000000000EL});
    public static final BitSet FOLLOW_125_in_classMember6302 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_classMember6305 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_namespace_in_classMember6308 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_classMember6311 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_125_in_classMember6314 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_classMember6317 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_functionDeclaration_in_classMember6320 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_126_in_classMember6325 = new BitSet(new long[]{0x0000000000000810L,0x6180800030000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_classMember6328 = new BitSet(new long[]{0x0000000000000810L,0x6180800030000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_namespace_in_classMember6331 = new BitSet(new long[]{0x0000000000000810L,0x6180800030000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_classMember6334 = new BitSet(new long[]{0x0000000000000810L,0x6180800030000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_126_in_classMember6337 = new BitSet(new long[]{0x0000000000000810L,0x6180800030000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_classMember6340 = new BitSet(new long[]{0x0000000000000810L,0x6180800030000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_functionDeclaration_in_classMember6344 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_variableStatement_in_classMember6348 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classMember_in_classElement6362 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_classElement6367 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_interfaceElements6379 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_interfaceElement_in_interfaceElements6382 = new BitSet(new long[]{0x0000000000000812L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_interfaceElements6384 = new BitSet(new long[]{0x0000000000000812L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_functionDeclaration_in_interfaceElement6398 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_qualifiedName6411 = new BitSet(new long[]{0x0000200000000002L});
    public static final BitSet FOLLOW_45_in_qualifiedName6414 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_Identifier_in_qualifiedName6416 = new BitSet(new long[]{0x0000200000000002L});
    public static final BitSet FOLLOW_80_in_defaultArgumentValue6431 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_defaultArgumentValue6433 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_assignmentExpressionNoIn_in_defaultArgumentValue6436 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_127_in_useNamespaceStatement6448 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_LineTerminator_in_useNamespaceStatement6450 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000000L,0x0000000000000001L});
    public static final BitSet FOLLOW_128_in_useNamespaceStatement6453 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_useNamespaceStatement6455 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_Identifier_in_useNamespaceStatement6458 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_useNamespaceStatement6461 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_useNamespaceStatement6466 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_38_in_metaDataStatement6478 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_metaDataStatement6480 = new BitSet(new long[]{0x0000000000000810L});
    public static final BitSet FOLLOW_Identifier_in_metaDataStatement6483 = new BitSet(new long[]{0x0000011000000810L});
    public static final BitSet FOLLOW_LineTerminator_in_metaDataStatement6485 = new BitSet(new long[]{0x0000011000000810L});
    public static final BitSet FOLLOW_formalParameterList_in_metaDataStatement6488 = new BitSet(new long[]{0x0000010000000010L});
    public static final BitSet FOLLOW_LineTerminator_in_metaDataStatement6491 = new BitSet(new long[]{0x0000010000000010L});
    public static final BitSet FOLLOW_40_in_metaDataStatement6494 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_129_in_includeStatement6506 = new BitSet(new long[]{0x0000000000100010L});
    public static final BitSet FOLLOW_LineTerminator_in_includeStatement6508 = new BitSet(new long[]{0x0000000000100010L});
    public static final BitSet FOLLOW_StringLiteral_in_includeStatement6511 = new BitSet(new long[]{0x0000000000000012L,0x0000000040000000L});
    public static final BitSet FOLLOW_LineTerminator_in_includeStatement6514 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_94_in_includeStatement6519 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_119_in_namespace6531 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_130_in_namespace6536 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_131_in_namespace6541 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_120_in_namespace6546 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedName_in_namespace6551 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_43_in_typeInformation6564 = new BitSet(new long[]{0x0204000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_typeInformation6566 = new BitSet(new long[]{0x0204000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_type_in_typeInformation6571 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_50_in_typeInformation6575 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_57_in_typeInformation6579 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedName_in_type6594 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_typeModifier_in_type6596 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_132_in_typeModifier6611 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_typeModifier6613 = new BitSet(new long[]{0x0000000000000810L,0x0180000000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_type_in_typeModifier6616 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000001L});
    public static final BitSet FOLLOW_LineTerminator_in_typeModifier6618 = new BitSet(new long[]{0x0000000000000010L,0x0000000000000001L});
    public static final BitSet FOLLOW_64_in_typeModifier6621 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred2_AS350 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_Identifier_in_synpred11_AS33531 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_qualifiedName_in_synpred12_AS33536 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred18_AS33581 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred40_AS33721 = new BitSet(new long[]{0x0000204000000010L});
    public static final BitSet FOLLOW_memberExpressionSuffix_in_synpred40_AS33724 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_memberExpression_in_synpred42_AS33755 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred46_AS33785 = new BitSet(new long[]{0x0000205000000010L});
    public static final BitSet FOLLOW_callExpressionSuffix_in_synpred46_AS33788 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_callExpression_in_synpred60_AS33911 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_synpred61_AS33927 = new BitSet(new long[]{0x0000800000000000L});
    public static final BitSet FOLLOW_47_in_synpred61_AS33929 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_leftHandSideExpression_in_synpred62_AS33934 = new BitSet(new long[]{0x0001000000000000L});
    public static final BitSet FOLLOW_48_in_synpred62_AS33936 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred81_AS34045 = new BitSet(new long[]{0x0060000000000010L});
    public static final BitSet FOLLOW_set_in_synpred81_AS34048 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred81_AS34056 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_multiplicativeExpression_in_synpred81_AS34059 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred95_AS34109 = new BitSet(new long[]{0x8000000000000010L,0x000000000000003FL});
    public static final BitSet FOLLOW_set_in_synpred95_AS34112 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred95_AS34140 = new BitSet(new long[]{0x01FF925C001E0810L,0x0000800000000000L});
    public static final BitSet FOLLOW_shiftExpression_in_synpred95_AS34143 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpression_in_synpred156_AS34597 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_conditionalExpressionNoIn_in_synpred159_AS34624 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_blockStatement_in_synpred179_AS34763 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_expressionStatement_in_synpred182_AS34778 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_labelledStatement_in_synpred189_AS34813 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred196_AS34861 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statementList_in_synpred197_AS34864 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred200_AS34888 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred204_AS34917 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred205_AS34917 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred212_AS34986 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred214_AS34992 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred216_AS35009 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred218_AS35015 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred222_AS35079 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred223_AS35079 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred230_AS35119 = new BitSet(new long[]{0x0000000000000010L,0x0000000100000000L});
    public static final BitSet FOLLOW_96_in_synpred230_AS35122 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred230_AS35124 = new BitSet(new long[]{0x01FF925C001E0810L,0x801099FEF0000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_statement_in_synpred230_AS35127 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_forStatement_in_synpred233_AS35150 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred237_AS35189 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred238_AS35189 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_Identifier_in_synpred264_AS35387 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred265_AS35391 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred266_AS35391 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_Identifier_in_synpred267_AS35410 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred268_AS35414 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred269_AS35414 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_expression_in_synpred270_AS35433 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred271_AS35437 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred272_AS35437 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred290_AS35571 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statementList_in_synpred291_AS35574 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred293_AS35594 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_statementList_in_synpred294_AS35597 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred297_AS35637 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred298_AS35637 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred301_AS35668 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred303_AS35677 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred316_AS35777 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred319_AS35788 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred321_AS35810 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred324_AS35821 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred327_AS35832 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred335_AS35892 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred337_AS35898 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred344_AS35941 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_functionDeclaration_in_synpred346_AS35955 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred347_AS35978 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred350_AS35989 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred352_AS36010 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred353_AS36015 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred359_AS36061 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred360_AS36061 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred364_AS36092 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred368_AS36119 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred370_AS36125 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred373_AS36136 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred378_AS36170 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred382_AS36198 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred385_AS36209 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred392_AS36283 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred393_AS36288 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_125_in_synpred395_AS36302 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred396_AS36305 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred398_AS36311 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_125_in_synpred401_AS36302 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_synpred401_AS36305 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_namespace_in_synpred401_AS36308 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_synpred401_AS36311 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_125_in_synpred401_AS36314 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_LineTerminator_in_synpred401_AS36317 = new BitSet(new long[]{0x0000000000000810L,0x2180800000000000L,0x000000000000000CL});
    public static final BitSet FOLLOW_functionDeclaration_in_synpred401_AS36320 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_126_in_synpred402_AS36325 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred403_AS36328 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred405_AS36334 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_classMember_in_synpred409_AS36362 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred411_AS36384 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_45_in_synpred413_AS36414 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_Identifier_in_synpred413_AS36416 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred417_AS36461 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred418_AS36461 = new BitSet(new long[]{0x0000000000000012L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred420_AS36485 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred424_AS36514 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_LineTerminator_in_synpred425_AS36514 = new BitSet(new long[]{0x0000000000000012L});

}